diff --git a/DiscImageChef.Tests/Checksums/CRC16.cs b/DiscImageChef.Tests/Checksums/CRC16.cs
index 0570c890..9a535a7f 100644
--- a/DiscImageChef.Tests/Checksums/CRC16.cs
+++ b/DiscImageChef.Tests/Checksums/CRC16.cs
@@ -33,20 +33,20 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class CRC16
+    public class Crc16
     {
         static readonly byte[] ExpectedEmpty = {0x00, 0x00};
         static readonly byte[] ExpectedRandom = {0x2d, 0x6d};
 
         [Test]
-        public void CRC16EmptyFile()
+        public void Crc16EmptyFile()
         {
             byte[] result = Crc16Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"));
             Assert.AreEqual(ExpectedEmpty, result);
         }
 
         [Test]
-        public void CRC16EmptyData()
+        public void Crc16EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -59,7 +59,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC16EmptyInstance()
+        public void Crc16EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -75,14 +75,14 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC16RandomFile()
+        public void Crc16RandomFile()
         {
             byte[] result = Crc16Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "random"));
             Assert.AreEqual(ExpectedRandom, result);
         }
 
         [Test]
-        public void CRC16RandomData()
+        public void Crc16RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -95,7 +95,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC16RandomInstance()
+        public void Crc16RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/CRC32.cs b/DiscImageChef.Tests/Checksums/CRC32.cs
index 78599c3d..9c590de6 100644
--- a/DiscImageChef.Tests/Checksums/CRC32.cs
+++ b/DiscImageChef.Tests/Checksums/CRC32.cs
@@ -33,20 +33,20 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class CRC32
+    public class Crc32
     {
         static readonly byte[] ExpectedEmpty = {0xa7, 0x38, 0xea, 0x1c};
         static readonly byte[] ExpectedRandom = {0x2b, 0x6e, 0x68, 0x54};
 
         [Test]
-        public void CRC32EmptyFile()
+        public void Crc32EmptyFile()
         {
             byte[] result = Crc32Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"));
             Assert.AreEqual(ExpectedEmpty, result);
         }
 
         [Test]
-        public void CRC32EmptyData()
+        public void Crc32EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -59,7 +59,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC32EmptyInstance()
+        public void Crc32EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -75,14 +75,14 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC32RandomFile()
+        public void Crc32RandomFile()
         {
             byte[] result = Crc32Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "random"));
             Assert.AreEqual(ExpectedRandom, result);
         }
 
         [Test]
-        public void CRC32RandomData()
+        public void Crc32RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -95,7 +95,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC32RandomInstance()
+        public void Crc32RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/CRC64.cs b/DiscImageChef.Tests/Checksums/CRC64.cs
index 71f33492..925da823 100644
--- a/DiscImageChef.Tests/Checksums/CRC64.cs
+++ b/DiscImageChef.Tests/Checksums/CRC64.cs
@@ -33,20 +33,20 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class CRC64
+    public class Crc64
     {
         static readonly byte[] ExpectedEmpty = {0x60, 0x6b, 0x70, 0xa2, 0x3e, 0xba, 0xf6, 0xc2};
         static readonly byte[] ExpectedRandom = {0xbf, 0x09, 0x99, 0x2c, 0xc5, 0xed, 0xe3, 0x8e};
 
         [Test]
-        public void CRC64EmptyFile()
+        public void Crc64EmptyFile()
         {
             byte[] result = Crc64Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"));
             Assert.AreEqual(ExpectedEmpty, result);
         }
 
         [Test]
-        public void CRC64EmptyData()
+        public void Crc64EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -59,7 +59,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC64EmptyInstance()
+        public void Crc64EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -75,14 +75,14 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC64RandomFile()
+        public void Crc64RandomFile()
         {
             byte[] result = Crc64Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "random"));
             Assert.AreEqual(ExpectedRandom, result);
         }
 
         [Test]
-        public void CRC64RandomData()
+        public void Crc64RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -95,7 +95,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void CRC64RandomInstance()
+        public void Crc64RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/MD5.cs b/DiscImageChef.Tests/Checksums/MD5.cs
index 2058c9db..97065b9d 100644
--- a/DiscImageChef.Tests/Checksums/MD5.cs
+++ b/DiscImageChef.Tests/Checksums/MD5.cs
@@ -33,7 +33,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class MD5
+    public class Md5
     {
         static readonly byte[] ExpectedEmpty =
             {0xb6, 0xd8, 0x1b, 0x36, 0x0a, 0x56, 0x72, 0xd8, 0x0c, 0x27, 0x43, 0x0f, 0x39, 0x15, 0x3e, 0x2c};
@@ -41,7 +41,7 @@ namespace DiscImageChef.Tests.Checksums
             {0xd7, 0x8f, 0x0e, 0xec, 0x41, 0x7b, 0xe3, 0x86, 0x21, 0x9b, 0x21, 0xb7, 0x00, 0x04, 0x4b, 0x95};
 
         [Test]
-        public void MD5EmptyFile()
+        public void Md5EmptyFile()
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
@@ -50,7 +50,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void MD5EmptyData()
+        public void Md5EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -65,7 +65,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void MD5EmptyInstance()
+        public void Md5EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -81,7 +81,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void MD5RandomFile()
+        public void Md5RandomFile()
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
@@ -90,7 +90,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void MD5RandomData()
+        public void Md5RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -105,7 +105,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void MD5RandomInstance()
+        public void Md5RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/RIPEMD160.cs b/DiscImageChef.Tests/Checksums/RIPEMD160.cs
index 16fef27b..e93f7b00 100644
--- a/DiscImageChef.Tests/Checksums/RIPEMD160.cs
+++ b/DiscImageChef.Tests/Checksums/RIPEMD160.cs
@@ -33,7 +33,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class RIPEMD160
+    public class Ripemd160
     {
         static readonly byte[] ExpectedEmpty =
         {
@@ -47,7 +47,7 @@ namespace DiscImageChef.Tests.Checksums
         };
 
         [Test]
-        public void RIPEMD160EmptyFile()
+        public void Ripemd160EmptyFile()
         {
             Ripemd160Context ctx = new Ripemd160Context();
             ctx.Init();
@@ -56,7 +56,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void RIPEMD160EmptyData()
+        public void Ripemd160EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -71,7 +71,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void RIPEMD160EmptyInstance()
+        public void Ripemd160EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void RIPEMD160RandomFile()
+        public void Ripemd160RandomFile()
         {
             Ripemd160Context ctx = new Ripemd160Context();
             ctx.Init();
@@ -96,7 +96,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void RIPEMD160RandomData()
+        public void Ripemd160RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -111,7 +111,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void RIPEMD160RandomInstance()
+        public void Ripemd160RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/SHA1.cs b/DiscImageChef.Tests/Checksums/SHA1.cs
index edf7e0fe..1bd103d1 100644
--- a/DiscImageChef.Tests/Checksums/SHA1.cs
+++ b/DiscImageChef.Tests/Checksums/SHA1.cs
@@ -33,7 +33,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class SHA1
+    public class Sha1
     {
         static readonly byte[] ExpectedEmpty =
         {
@@ -47,7 +47,7 @@ namespace DiscImageChef.Tests.Checksums
         };
 
         [Test]
-        public void SHA1EmptyFile()
+        public void Sha1EmptyFile()
         {
             Sha1Context ctx = new Sha1Context();
             ctx.Init();
@@ -56,7 +56,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA1EmptyData()
+        public void Sha1EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -71,7 +71,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA1EmptyInstance()
+        public void Sha1EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA1RandomFile()
+        public void Sha1RandomFile()
         {
             Sha1Context ctx = new Sha1Context();
             ctx.Init();
@@ -96,7 +96,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA1RandomData()
+        public void Sha1RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -111,7 +111,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA1RandomInstance()
+        public void Sha1RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/SHA256.cs b/DiscImageChef.Tests/Checksums/SHA256.cs
index 6d9c99d2..6c75ff53 100644
--- a/DiscImageChef.Tests/Checksums/SHA256.cs
+++ b/DiscImageChef.Tests/Checksums/SHA256.cs
@@ -33,7 +33,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class SHA256
+    public class Sha256
     {
         static readonly byte[] ExpectedEmpty =
         {
@@ -47,7 +47,7 @@ namespace DiscImageChef.Tests.Checksums
         };
 
         [Test]
-        public void SHA256EmptyFile()
+        public void Sha256EmptyFile()
         {
             Sha256Context ctx = new Sha256Context();
             ctx.Init();
@@ -56,7 +56,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA256EmptyData()
+        public void Sha256EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -71,7 +71,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA256EmptyInstance()
+        public void Sha256EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA256RandomFile()
+        public void Sha256RandomFile()
         {
             Sha256Context ctx = new Sha256Context();
             ctx.Init();
@@ -96,7 +96,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA256RandomData()
+        public void Sha256RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -111,7 +111,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA256RandomInstance()
+        public void Sha256RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/SHA384.cs b/DiscImageChef.Tests/Checksums/SHA384.cs
index 895c4834..35d4c360 100644
--- a/DiscImageChef.Tests/Checksums/SHA384.cs
+++ b/DiscImageChef.Tests/Checksums/SHA384.cs
@@ -33,7 +33,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class SHA384
+    public class Sha384
     {
         static readonly byte[] ExpectedEmpty =
         {
@@ -49,7 +49,7 @@ namespace DiscImageChef.Tests.Checksums
         };
 
         [Test]
-        public void SHA384EmptyFile()
+        public void Sha384EmptyFile()
         {
             Sha384Context ctx = new Sha384Context();
             ctx.Init();
@@ -58,7 +58,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA384EmptyData()
+        public void Sha384EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -73,7 +73,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA384EmptyInstance()
+        public void Sha384EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -89,7 +89,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA384RandomFile()
+        public void Sha384RandomFile()
         {
             Sha384Context ctx = new Sha384Context();
             ctx.Init();
@@ -98,7 +98,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA384RandomData()
+        public void Sha384RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -113,7 +113,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA384RandomInstance()
+        public void Sha384RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/SHA512.cs b/DiscImageChef.Tests/Checksums/SHA512.cs
index 11a86d30..a6c3839f 100644
--- a/DiscImageChef.Tests/Checksums/SHA512.cs
+++ b/DiscImageChef.Tests/Checksums/SHA512.cs
@@ -33,7 +33,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Checksums
 {
     [TestFixture]
-    public class SHA512
+    public class Sha512
     {
         static readonly byte[] ExpectedEmpty =
         {
@@ -51,7 +51,7 @@ namespace DiscImageChef.Tests.Checksums
         };
 
         [Test]
-        public void SHA512EmptyFile()
+        public void Sha512EmptyFile()
         {
             Sha512Context ctx = new Sha512Context();
             ctx.Init();
@@ -60,7 +60,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA512EmptyData()
+        public void Sha512EmptyData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA512EmptyInstance()
+        public void Sha512EmptyInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
@@ -91,7 +91,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA512RandomFile()
+        public void Sha512RandomFile()
         {
             Sha512Context ctx = new Sha512Context();
             ctx.Init();
@@ -100,7 +100,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA512RandomData()
+        public void Sha512RandomData()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
@@ -115,7 +115,7 @@ namespace DiscImageChef.Tests.Checksums
         }
 
         [Test]
-        public void SHA512RandomInstance()
+        public void Sha512RandomInstance()
         {
             byte[] data = new byte[1048576];
             FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
diff --git a/DiscImageChef.Tests/Checksums/SpamSum.cs b/DiscImageChef.Tests/Checksums/SpamSum.cs
index 9ac98766..bc8097bf 100644
--- a/DiscImageChef.Tests/Checksums/SpamSum.cs
+++ b/DiscImageChef.Tests/Checksums/SpamSum.cs
@@ -35,8 +35,8 @@ namespace DiscImageChef.Tests.Checksums
     [TestFixture]
     public class SpamSum
     {
-        static readonly string ExpectedEmpty = "3::";
-        static readonly string ExpectedRandom = "24576:3dvzuAsHTQ16pc7O1Q/gS9qze+Swwn9s6IX:8/TQQpaVqze+JN6IX";
+        const string EXPECTED_EMPTY = "3::";
+        const string EXPECTED_RANDOM = "24576:3dvzuAsHTQ16pc7O1Q/gS9qze+Swwn9s6IX:8/TQQpaVqze+JN6IX";
 
         [Test]
         public void SpamSumEmptyData()
@@ -47,9 +47,8 @@ namespace DiscImageChef.Tests.Checksums
             fs.Read(data, 0, 1048576);
             fs.Close();
             fs.Dispose();
-            SpamSumContext ctx = new SpamSumContext();
-            string result = SpamSumContext.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedEmpty, result);
+            string result = SpamSumContext.Data(data, out _);
+            Assert.AreEqual(EXPECTED_EMPTY, result);
         }
 
         [Test]
@@ -65,7 +64,7 @@ namespace DiscImageChef.Tests.Checksums
             ctx.Init();
             ctx.Update(data);
             string result = ctx.End();
-            Assert.AreEqual(ExpectedEmpty, result);
+            Assert.AreEqual(EXPECTED_EMPTY, result);
         }
 
         [Test]
@@ -77,9 +76,8 @@ namespace DiscImageChef.Tests.Checksums
             fs.Read(data, 0, 1048576);
             fs.Close();
             fs.Dispose();
-            SpamSumContext ctx = new SpamSumContext();
-            string result = SpamSumContext.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedRandom, result);
+            string result = SpamSumContext.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RANDOM, result);
         }
 
         [Test]
@@ -95,7 +93,7 @@ namespace DiscImageChef.Tests.Checksums
             ctx.Init();
             ctx.Update(data);
             string result = ctx.End();
-            Assert.AreEqual(ExpectedRandom, result);
+            Assert.AreEqual(EXPECTED_RANDOM, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Devices/LS120.cs b/DiscImageChef.Tests/Devices/LS120.cs
index d4b89cc1..37fe7f15 100644
--- a/DiscImageChef.Tests/Devices/LS120.cs
+++ b/DiscImageChef.Tests/Devices/LS120.cs
@@ -35,7 +35,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Devices
 {
     [TestFixture]
-    public class LS120
+    public class Ls120
     {
         readonly string[] testfiles = {"ls120.bin.lz", "mf2dd.bin.lz", "mf2hd.bin.lz"};
 
diff --git a/DiscImageChef.Tests/Filesystems/ADFS.cs b/DiscImageChef.Tests/Filesystems/ADFS.cs
index 2629b81b..aab8a0fb 100644
--- a/DiscImageChef.Tests/Filesystems/ADFS.cs
+++ b/DiscImageChef.Tests/Filesystems/ADFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class ADFS
+    public class Adfs
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(bootable[i], fs.XmlFSType.Bootable, testfiles[i]);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFFS.cs b/DiscImageChef.Tests/Filesystems/AFFS.cs
index 9da72642..07df391a 100644
--- a/DiscImageChef.Tests/Filesystems/AFFS.cs
+++ b/DiscImageChef.Tests/Filesystems/AFFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFFS
+    public class Affs
     {
         readonly string[] testfiles = {"amigaos_3.9.adf.lz", "amigaos_3.9_intl.adf.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga FFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFFS2_RDB.cs b/DiscImageChef.Tests/Filesystems/AFFS2_RDB.cs
index 64d5ed0b..8695d3f0 100644
--- a/DiscImageChef.Tests/Filesystems/AFFS2_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/AFFS2_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFFS2_RDB
+    public class Affs2Rdb
     {
         readonly string[] testfiles = {"amigaos_4.0.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga FFS2", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFFS_MBR.cs b/DiscImageChef.Tests/Filesystems/AFFS_MBR.cs
index a0a331fb..b1074732 100644
--- a/DiscImageChef.Tests/Filesystems/AFFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/AFFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFFS_MBR
+    public class AffsMbr
     {
         readonly string[] testfiles = {"aros.vdi.lz", "aros_intl.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga FFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFFS_MBR_RDB.cs b/DiscImageChef.Tests/Filesystems/AFFS_MBR_RDB.cs
index a56eb52c..37b6a504 100644
--- a/DiscImageChef.Tests/Filesystems/AFFS_MBR_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/AFFS_MBR_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFFS_MBR_RDB
+    public class AffsMbrRdb
     {
         readonly string[] testfiles = {"aros.vdi.lz", "aros_intl.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga FFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFFS_RDB.cs b/DiscImageChef.Tests/Filesystems/AFFS_RDB.cs
index 578db4b7..34bfe27d 100644
--- a/DiscImageChef.Tests/Filesystems/AFFS_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/AFFS_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFFS_RDB
+    public class AffsRdb
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga FFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFS.cs b/DiscImageChef.Tests/Filesystems/AFS.cs
index abe6268f..700da220 100644
--- a/DiscImageChef.Tests/Filesystems/AFS.cs
+++ b/DiscImageChef.Tests/Filesystems/AFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFS
+    public class Afs
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AFS_MBR.cs b/DiscImageChef.Tests/Filesystems/AFS_MBR.cs
index 6ef39110..f2f5d8c8 100644
--- a/DiscImageChef.Tests/Filesystems/AFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/AFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AFS_MBR
+    public class AfsMbr
     {
         readonly string[] testfiles = {"scoopenserver_5.0.7hw.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AOFS.cs b/DiscImageChef.Tests/Filesystems/AOFS.cs
index c1886b1c..5700a2e8 100644
--- a/DiscImageChef.Tests/Filesystems/AOFS.cs
+++ b/DiscImageChef.Tests/Filesystems/AOFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AOFS
+    public class Aofs
     {
         readonly string[] testfiles = {"amigaos_3.9.adf.lz", "amigaos_3.9_intl.adf.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga OFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AOFS_MBR.cs b/DiscImageChef.Tests/Filesystems/AOFS_MBR.cs
index aa0fa33d..0a3f3aa5 100644
--- a/DiscImageChef.Tests/Filesystems/AOFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/AOFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AOFS_MBR
+    public class AofsMbr
     {
         readonly string[] testfiles = {"aros.vdi.lz", "aros_intl.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga OFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AOFS_MBR_RDB.cs b/DiscImageChef.Tests/Filesystems/AOFS_MBR_RDB.cs
index 9707627f..08d71ab1 100644
--- a/DiscImageChef.Tests/Filesystems/AOFS_MBR_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/AOFS_MBR_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AOFS_MBR_RDB
+    public class AofsMbrRdb
     {
         readonly string[] testfiles = {"aros.vdi.lz", "aros_intl.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga OFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/AOFS_RDB.cs b/DiscImageChef.Tests/Filesystems/AOFS_RDB.cs
index 598de9bc..e9362662 100644
--- a/DiscImageChef.Tests/Filesystems/AOFS_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/AOFS_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class AOFS_RDB
+    public class AofsRdb
     {
         readonly string[] testfiles =
             {"amigaos_3.9.vdi.lz", "amigaos_3.9_intl.vdi.lz", "aros.vdi.lz", "aros_intl.vdi.lz"};
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Amiga OFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/Atheos_MBR.cs b/DiscImageChef.Tests/Filesystems/Atheos_MBR.cs
index 6cd5a1db..06a7f179 100644
--- a/DiscImageChef.Tests/Filesystems/Atheos_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/Atheos_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class Atheos_MBR
+    public class AtheosMbr
     {
         readonly string[] testfiles = {"syllable_0.6.7.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("AtheOS filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/BeFS.cs b/DiscImageChef.Tests/Filesystems/BeFS.cs
index 756611cc..230ae9f5 100644
--- a/DiscImageChef.Tests/Filesystems/BeFS.cs
+++ b/DiscImageChef.Tests/Filesystems/BeFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class BeFS
+    public class BeFs
     {
         readonly string[] testfiles = {"beos_r3.1.img.lz", "beos_r4.5.img.lz"};
 
@@ -69,7 +69,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
-                Filesystem fs = new DiscImageChef.Filesystems.BeFS();
+                Filesystem fs = new BeFS();
                 Partition wholePart = new Partition
                 {
                     Name = "Whole device",
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("BeFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/BeFS_APM.cs b/DiscImageChef.Tests/Filesystems/BeFS_APM.cs
index 063676da..37991ce7 100644
--- a/DiscImageChef.Tests/Filesystems/BeFS_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/BeFS_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class BeFS_APM
+    public class BeFsApm
     {
         readonly string[] testfiles = {"beos_r3.1.vdi.lz", "beos_r4.5.vdi.lz"};
 
@@ -68,7 +68,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 List<Partition> partitions = Core.Partitions.GetAll(image);
-                Filesystem fs = new DiscImageChef.Filesystems.BeFS();
+                Filesystem fs = new BeFS();
                 int part = -1;
                 for(int j = 0; j < partitions.Count; j++)
                     if(partitions[j].Type == "Be_BFS")
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("BeFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/BeFS_GPT.cs b/DiscImageChef.Tests/Filesystems/BeFS_GPT.cs
index 65f839eb..6a18df24 100644
--- a/DiscImageChef.Tests/Filesystems/BeFS_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/BeFS_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class BeFS_GPT
+    public class BeFsGpt
     {
         readonly string[] testfiles = {"haiku_hrev51259.vdi.lz"};
 
@@ -66,7 +66,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 List<Partition> partitions = Core.Partitions.GetAll(image);
-                Filesystem fs = new DiscImageChef.Filesystems.BeFS();
+                Filesystem fs = new BeFS();
                 int part = -1;
                 for(int j = 0; j < partitions.Count; j++)
                     if(partitions[j].Type == "Haiku BFS")
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("BeFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/BeFS_MBR.cs b/DiscImageChef.Tests/Filesystems/BeFS_MBR.cs
index 28617b8a..1db93133 100644
--- a/DiscImageChef.Tests/Filesystems/BeFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/BeFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class BeFS_MBR
+    public class BeFsMbr
     {
         readonly string[] testfiles =
             {"beos_r3.1.vdi.lz", "beos_r4.5.vdi.lz", "haiku_hrev51259.vdi.lz", "syllable_0.6.7.vdi.lz"};
@@ -67,7 +67,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 List<Partition> partitions = Core.Partitions.GetAll(image);
-                Filesystem fs = new DiscImageChef.Filesystems.BeFS();
+                Filesystem fs = new BeFS();
                 int part = -1;
                 for(int j = 0; j < partitions.Count; j++)
                     if(partitions[j].Type == "0xEB")
@@ -78,7 +78,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("BeFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/COHERENT.cs b/DiscImageChef.Tests/Filesystems/COHERENT.cs
index f74f0fb4..9b82f243 100644
--- a/DiscImageChef.Tests/Filesystems/COHERENT.cs
+++ b/DiscImageChef.Tests/Filesystems/COHERENT.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class COHERENT
+    public class Coherent
     {
         readonly string[] testfiles =
         {
@@ -82,7 +82,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/COHERENT_MBR.cs b/DiscImageChef.Tests/Filesystems/COHERENT_MBR.cs
index c128e7dd..f53f9c12 100644
--- a/DiscImageChef.Tests/Filesystems/COHERENT_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/COHERENT_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class COHERENT_MBR
+    public class CoherentMbr
     {
         readonly string[] testfiles = {"coherentunix_4.2.10.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/DTFS.cs b/DiscImageChef.Tests/Filesystems/DTFS.cs
index 581ca199..6a630e20 100644
--- a/DiscImageChef.Tests/Filesystems/DTFS.cs
+++ b/DiscImageChef.Tests/Filesystems/DTFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class DTFS
+    public class Dtfs
     {
         readonly string[] testfiles =
         {
@@ -83,7 +83,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/DTFS_MBR.cs b/DiscImageChef.Tests/Filesystems/DTFS_MBR.cs
index 047023fc..81c34d44 100644
--- a/DiscImageChef.Tests/Filesystems/DTFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/DTFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class DTFS_MBR
+    public class DtfsMbr
     {
         readonly string[] testfiles = {"scoopenserver_5.0.7hw.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/EAFS.cs b/DiscImageChef.Tests/Filesystems/EAFS.cs
index 4f06a4ed..5d1ebd53 100644
--- a/DiscImageChef.Tests/Filesystems/EAFS.cs
+++ b/DiscImageChef.Tests/Filesystems/EAFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class EAFS
+    public class Eafs
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/EAFS_MBR.cs b/DiscImageChef.Tests/Filesystems/EAFS_MBR.cs
index f65529f1..5c49b8cd 100644
--- a/DiscImageChef.Tests/Filesystems/EAFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/EAFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class EAFS_MBR
+    public class EafsMbr
     {
         readonly string[] testfiles = {"scoopenserver_5.0.7hw.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/F2FS.cs b/DiscImageChef.Tests/Filesystems/F2FS.cs
index cb19796a..8528ddde 100644
--- a/DiscImageChef.Tests/Filesystems/F2FS.cs
+++ b/DiscImageChef.Tests/Filesystems/F2FS.cs
@@ -38,7 +38,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class F2FS
+    public class F2Fs
     {
         readonly string[] testfiles = {"linux.vdi.lz"};
 
@@ -68,7 +68,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 PartitionPlugin parts = new MBR();
                 Assert.AreEqual(true, parts.GetInformation(image, out List<Partition> partitions, 0), testfiles[i]);
-                Filesystem fs = new DiscImageChef.Filesystems.F2FS();
+                Filesystem fs = new F2FS();
                 int part = -1;
                 for(int j = 0; j < partitions.Count; j++)
                     if(partitions[j].Type == "0x83")
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("F2FS filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT12.cs b/DiscImageChef.Tests/Filesystems/FAT12.cs
index 4764210c..7efeb714 100644
--- a/DiscImageChef.Tests/Filesystems/FAT12.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT12.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT12
+    public class Fat12
     {
         readonly string[] testfiles =
         {
@@ -1724,7 +1724,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT12", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT12_APM.cs b/DiscImageChef.Tests/Filesystems/FAT12_APM.cs
index 177fefa2..37cc3243 100644
--- a/DiscImageChef.Tests/Filesystems/FAT12_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT12_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT12_APM
+    public class Fat12Apm
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT12", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT12_GPT.cs b/DiscImageChef.Tests/Filesystems/FAT12_GPT.cs
index 093e5d33..ffe10178 100644
--- a/DiscImageChef.Tests/Filesystems/FAT12_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT12_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT12_GPT
+    public class Fat12Gpt
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT12", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT12_MBR.cs b/DiscImageChef.Tests/Filesystems/FAT12_MBR.cs
index 3cf82253..c12763b3 100644
--- a/DiscImageChef.Tests/Filesystems/FAT12_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT12_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT12_MBR
+    public class Fat12Mbr
     {
         readonly string[] testfiles =
         {
@@ -138,7 +138,7 @@ namespace DiscImageChef.Tests.Filesystems
                 List<Partition> partitions = Core.Partitions.GetAll(image);
                 Filesystem fs = new FAT();
                 Assert.AreEqual(true, fs.Identify(image, partitions[0]), testfiles[i]);
-                fs.GetInformation(image, partitions[0], out string information);
+                fs.GetInformation(image, partitions[0], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT12", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT16.cs b/DiscImageChef.Tests/Filesystems/FAT16.cs
index d1e08d9f..344765cf 100644
--- a/DiscImageChef.Tests/Filesystems/FAT16.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT16.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT16
+    public class Fat16
     {
         readonly string[] testfiles =
         {
@@ -131,7 +131,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT16", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT16_APM.cs b/DiscImageChef.Tests/Filesystems/FAT16_APM.cs
index aabe2754..2ace96db 100644
--- a/DiscImageChef.Tests/Filesystems/FAT16_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT16_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT16_APM
+    public class Fat16Apm
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT16", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT16_Atari.cs b/DiscImageChef.Tests/Filesystems/FAT16_Atari.cs
index adb1d6f1..8b68da21 100644
--- a/DiscImageChef.Tests/Filesystems/FAT16_Atari.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT16_Atari.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT16_Atari
+    public class Fat16Atari
     {
         readonly string[] testfiles = {"tos_1.04.vdi.lz", "tos_1.04_small.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT16", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT16_GPT.cs b/DiscImageChef.Tests/Filesystems/FAT16_GPT.cs
index 9595b541..ef357f9e 100644
--- a/DiscImageChef.Tests/Filesystems/FAT16_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT16_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT16_GPT
+    public class Fat16Gpt
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT16", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT16_MBR.cs b/DiscImageChef.Tests/Filesystems/FAT16_MBR.cs
index 08c5b7fd..8d7241d2 100644
--- a/DiscImageChef.Tests/Filesystems/FAT16_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT16_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT16_MBR
+    public class Fat16Mbr
     {
         readonly string[] testfiles =
         {
@@ -140,7 +140,7 @@ namespace DiscImageChef.Tests.Filesystems
                 List<Partition> partitions = Core.Partitions.GetAll(image);
                 Filesystem fs = new FAT();
                 Assert.AreEqual(true, fs.Identify(image, partitions[0]), testfiles[i]);
-                fs.GetInformation(image, partitions[0], out string information);
+                fs.GetInformation(image, partitions[0], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT16", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT16_RDB.cs b/DiscImageChef.Tests/Filesystems/FAT16_RDB.cs
index 99387b18..07021775 100644
--- a/DiscImageChef.Tests/Filesystems/FAT16_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT16_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT16_RDB
+    public class Fat16Rdb
     {
         readonly string[] testfiles = {"amigaos_3.9.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT16", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT32_APM.cs b/DiscImageChef.Tests/Filesystems/FAT32_APM.cs
index 24a6b070..cb6e3797 100644
--- a/DiscImageChef.Tests/Filesystems/FAT32_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT32_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT32_APM
+    public class Fat32Apm
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT32", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT32_GPT.cs b/DiscImageChef.Tests/Filesystems/FAT32_GPT.cs
index 842fa212..dbd0327f 100644
--- a/DiscImageChef.Tests/Filesystems/FAT32_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT32_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT32_GPT
+    public class Fat32Gpt
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT32", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/FAT32_MBR.cs b/DiscImageChef.Tests/Filesystems/FAT32_MBR.cs
index 86bc9009..e0e1e5a6 100644
--- a/DiscImageChef.Tests/Filesystems/FAT32_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/FAT32_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class FAT32_MBR
+    public class Fat32Mbr
     {
         readonly string[] testfiles =
         {
@@ -104,7 +104,7 @@ namespace DiscImageChef.Tests.Filesystems
                 List<Partition> partitions = Core.Partitions.GetAll(image);
                 Filesystem fs = new FAT();
                 Assert.AreEqual(true, fs.Identify(image, partitions[0]), testfiles[i]);
-                fs.GetInformation(image, partitions[0], out string information);
+                fs.GetInformation(image, partitions[0], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("FAT32", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HAMMER_MBR.cs b/DiscImageChef.Tests/Filesystems/HAMMER_MBR.cs
index 1cb2ceb4..57e1f5fd 100644
--- a/DiscImageChef.Tests/Filesystems/HAMMER_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/HAMMER_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HAMMER_MBR
+    public class HammerMbr
     {
         readonly string[] testfiles = {"dflybsd_3.6.1.vdi.lz", "dflybsd_4.0.5.vdi.lz"};
 
@@ -78,7 +78,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HAMMER", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFS.cs b/DiscImageChef.Tests/Filesystems/HFS.cs
index 0a6d5db8..b802b647 100644
--- a/DiscImageChef.Tests/Filesystems/HFS.cs
+++ b/DiscImageChef.Tests/Filesystems/HFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFS
+    public class Hfs
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFSPlus_APM.cs b/DiscImageChef.Tests/Filesystems/HFSPlus_APM.cs
index a8ac7379..7c5565ef 100644
--- a/DiscImageChef.Tests/Filesystems/HFSPlus_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/HFSPlus_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFSPlus_APM
+    public class HfsPlusApm
     {
         // Missing Darwin 1.4.1
         readonly string[] testfiles =
@@ -113,7 +113,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS+", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFSPlus_GPT.cs b/DiscImageChef.Tests/Filesystems/HFSPlus_GPT.cs
index f80e704f..86ac16d8 100644
--- a/DiscImageChef.Tests/Filesystems/HFSPlus_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/HFSPlus_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFSPlus_GPT
+    public class HfsPlusGpt
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz", "macosx_10.11_journal.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS+", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFSPlus_MBR.cs b/DiscImageChef.Tests/Filesystems/HFSPlus_MBR.cs
index 57c5e136..f23fe421 100644
--- a/DiscImageChef.Tests/Filesystems/HFSPlus_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/HFSPlus_MBR.cs
@@ -38,7 +38,7 @@ namespace DiscImageChef.Tests.Filesystems
 {
     // Mising Darwin 6.0.2 wrapped
     [TestFixture]
-    public class HFSPlus_MBR
+    public class HfsPlusMbr
     {
         readonly string[] testfiles =
         {
@@ -92,7 +92,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS+", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFSX_APM.cs b/DiscImageChef.Tests/Filesystems/HFSX_APM.cs
index d73776fc..39c3ab6c 100644
--- a/DiscImageChef.Tests/Filesystems/HFSX_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/HFSX_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFSX_APM
+    public class HfsxApm
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFSX", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFSX_GPT.cs b/DiscImageChef.Tests/Filesystems/HFSX_GPT.cs
index 2dd6e750..7a0170fb 100644
--- a/DiscImageChef.Tests/Filesystems/HFSX_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/HFSX_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFSX_GPT
+    public class HfsxGpt
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz", "macosx_10.11_journal.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFSX", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFSX_MBR.cs b/DiscImageChef.Tests/Filesystems/HFSX_MBR.cs
index c70f5ac4..0e7907c3 100644
--- a/DiscImageChef.Tests/Filesystems/HFSX_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/HFSX_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFSX_MBR
+    public class HfsxMbr
     {
         readonly string[] testfiles =
         {
@@ -84,7 +84,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFSX", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFS_APM.cs b/DiscImageChef.Tests/Filesystems/HFS_APM.cs
index fcdf4cf5..32ceaeda 100644
--- a/DiscImageChef.Tests/Filesystems/HFS_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/HFS_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFS_APM
+    public class HfsApm
     {
         readonly string[] testfiles =
         {
@@ -118,7 +118,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFS_CDROM.cs b/DiscImageChef.Tests/Filesystems/HFS_CDROM.cs
index d24950de..7fdb250a 100644
--- a/DiscImageChef.Tests/Filesystems/HFS_CDROM.cs
+++ b/DiscImageChef.Tests/Filesystems/HFS_CDROM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFS_CDROM
+    public class HfsCdrom
     {
         readonly string[] testfiles =
         {
@@ -83,7 +83,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFS_MBR.cs b/DiscImageChef.Tests/Filesystems/HFS_MBR.cs
index 50552679..a3cb7ad0 100644
--- a/DiscImageChef.Tests/Filesystems/HFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/HFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFS_MBR
+    public class HfsMbr
     {
         readonly string[] testfiles =
         {
@@ -81,7 +81,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HFS_RDB.cs b/DiscImageChef.Tests/Filesystems/HFS_RDB.cs
index 561e0f79..5376d410 100644
--- a/DiscImageChef.Tests/Filesystems/HFS_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/HFS_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HFS_RDB
+    public class HfsRdb
     {
         readonly string[] testfiles = {"amigaos_3.9.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HPFS.cs b/DiscImageChef.Tests/Filesystems/HPFS.cs
index 7824a508..8adcd7e0 100644
--- a/DiscImageChef.Tests/Filesystems/HPFS.cs
+++ b/DiscImageChef.Tests/Filesystems/HPFS.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HPFS
+    public class Hpfs
     {
         readonly string[] testfiles =
         {
@@ -87,9 +87,9 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 List<Partition> partitions = Core.Partitions.GetAll(image);
-                Filesystem fs = new DiscImageChef.Filesystems.HPFS();
+                Filesystem fs = new HPFS();
                 Assert.AreEqual(true, fs.Identify(image, partitions[0]), testfiles[i]);
-                fs.GetInformation(image, partitions[0], out string information);
+                fs.GetInformation(image, partitions[0], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("HPFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HTFS.cs b/DiscImageChef.Tests/Filesystems/HTFS.cs
index a197b0a4..aa83dc5a 100644
--- a/DiscImageChef.Tests/Filesystems/HTFS.cs
+++ b/DiscImageChef.Tests/Filesystems/HTFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HTFS
+    public class Htfs
     {
         readonly string[] testfiles =
         {
@@ -83,7 +83,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/HTFS_MBR.cs b/DiscImageChef.Tests/Filesystems/HTFS_MBR.cs
index 6ad1fca0..8bd837bc 100644
--- a/DiscImageChef.Tests/Filesystems/HTFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/HTFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class HTFS_MBR
+    public class HtfsMbr
     {
         readonly string[] testfiles = {"scoopenserver_5.0.7hw.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/ISO9660.cs b/DiscImageChef.Tests/Filesystems/ISO9660.cs
index 32e3bf10..033467fd 100644
--- a/DiscImageChef.Tests/Filesystems/ISO9660.cs
+++ b/DiscImageChef.Tests/Filesystems/ISO9660.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class ISO9660
+    public class Iso9660
     {
         readonly string[] testfiles =
         {
@@ -134,7 +134,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("ISO9660", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/JFS2.cs b/DiscImageChef.Tests/Filesystems/JFS2.cs
index d747e89a..e0f5cdef 100644
--- a/DiscImageChef.Tests/Filesystems/JFS2.cs
+++ b/DiscImageChef.Tests/Filesystems/JFS2.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class JFS2
+    public class Jfs2
     {
         readonly string[] testfiles = {"linux.vdi.lz", "linux_caseinsensitive.vdi.lz"};
 
@@ -78,7 +78,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("JFS filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/LFS_MBR.cs b/DiscImageChef.Tests/Filesystems/LFS_MBR.cs
index aa922dc9..aa8b41a5 100644
--- a/DiscImageChef.Tests/Filesystems/LFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/LFS_MBR.cs
@@ -32,7 +32,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class LFS_MBR
+    public class LfsMbr
     {
         readonly string[] testfiles = {"netbsd_1.6.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
                 }
                 Assert.AreNotEqual(-1, part, string.Format("Partition not found on {0}", testfiles[i]));
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("LFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/LisaFS.cs b/DiscImageChef.Tests/Filesystems/LisaFS.cs
index d3a1c85b..c00a7281 100644
--- a/DiscImageChef.Tests/Filesystems/LisaFS.cs
+++ b/DiscImageChef.Tests/Filesystems/LisaFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class LisaFS
+    public class LisaFs
     {
         readonly string[] testfiles =
         {
@@ -99,7 +99,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("LisaFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/Locus.cs b/DiscImageChef.Tests/Filesystems/Locus.cs
index 18dca597..2a9fab12 100644
--- a/DiscImageChef.Tests/Filesystems/Locus.cs
+++ b/DiscImageChef.Tests/Filesystems/Locus.cs
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Locus filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MFS.cs b/DiscImageChef.Tests/Filesystems/MFS.cs
index 69d54230..fdbfd9ed 100644
--- a/DiscImageChef.Tests/Filesystems/MFS.cs
+++ b/DiscImageChef.Tests/Filesystems/MFS.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MFS
+    public class Mfs
     {
         readonly string[] testfiles =
         {
@@ -85,7 +85,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("MFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MINIXv1.cs b/DiscImageChef.Tests/Filesystems/MINIXv1.cs
index e0a88209..eee1bc93 100644
--- a/DiscImageChef.Tests/Filesystems/MINIXv1.cs
+++ b/DiscImageChef.Tests/Filesystems/MINIXv1.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MINIXv1
+    public class MinixV1
     {
         readonly string[] testfiles =
         {
@@ -78,7 +78,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(types[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MINIXv1_MBR.cs b/DiscImageChef.Tests/Filesystems/MINIXv1_MBR.cs
index a5d97b3e..0b3a3107 100644
--- a/DiscImageChef.Tests/Filesystems/MINIXv1_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/MINIXv1_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MINIXv1_MBR
+    public class MinixV1Mbr
     {
         readonly string[] testfiles = {"linux.vdi.lz", "minix_3.1.2a.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(types[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MINIXv2.cs b/DiscImageChef.Tests/Filesystems/MINIXv2.cs
index 69dfaa43..969a66f2 100644
--- a/DiscImageChef.Tests/Filesystems/MINIXv2.cs
+++ b/DiscImageChef.Tests/Filesystems/MINIXv2.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MINIXv2
+    public class MinixV2
     {
         readonly string[] testfiles =
         {
@@ -78,7 +78,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(types[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MINIXv2_MBR.cs b/DiscImageChef.Tests/Filesystems/MINIXv2_MBR.cs
index 3d57407c..9e378c3d 100644
--- a/DiscImageChef.Tests/Filesystems/MINIXv2_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/MINIXv2_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MINIXv2_MBR
+    public class MinixV2Mbr
     {
         readonly string[] testfiles = {"minix_3.1.2a.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(types[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MINIXv3.cs b/DiscImageChef.Tests/Filesystems/MINIXv3.cs
index e934f87d..fea0feb3 100644
--- a/DiscImageChef.Tests/Filesystems/MINIXv3.cs
+++ b/DiscImageChef.Tests/Filesystems/MINIXv3.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MINIXv3
+    public class MinixV3
     {
         readonly string[] testfiles =
         {
@@ -78,7 +78,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(types[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/MINIXv3_MBR.cs b/DiscImageChef.Tests/Filesystems/MINIXv3_MBR.cs
index 7cca8d10..5a3f7299 100644
--- a/DiscImageChef.Tests/Filesystems/MINIXv3_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/MINIXv3_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class MINIXv3_MBR
+    public class MinixV3Mbr
     {
         readonly string[] testfiles = {"minix_3.1.2a.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(types[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/NILFS2.cs b/DiscImageChef.Tests/Filesystems/NILFS2.cs
index bf09ba21..52d1b859 100644
--- a/DiscImageChef.Tests/Filesystems/NILFS2.cs
+++ b/DiscImageChef.Tests/Filesystems/NILFS2.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class NILFS2
+    public class Nilfs2
     {
         readonly string[] testfiles = {"linux.vdi.lz"};
 
@@ -66,7 +66,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 List<Partition> partitions = Core.Partitions.GetAll(image);
-                Filesystem fs = new DiscImageChef.Filesystems.NILFS2();
+                Filesystem fs = new NILFS2();
                 int part = -1;
                 for(int j = 0; j < partitions.Count; j++)
                     if(partitions[j].Type == "0x83")
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("NILFS2 filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/NTFS_GPT.cs b/DiscImageChef.Tests/Filesystems/NTFS_GPT.cs
index 31c463fb..b1457fc6 100644
--- a/DiscImageChef.Tests/Filesystems/NTFS_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/NTFS_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class NTFS_GPT
+    public class NtfsGpt
     {
         readonly string[] testfiles = {"haiku_hrev51259.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("NTFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/NTFS_MBR.cs b/DiscImageChef.Tests/Filesystems/NTFS_MBR.cs
index b7246e87..b5f88917 100644
--- a/DiscImageChef.Tests/Filesystems/NTFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/NTFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class NTFS_MBR
+    public class NtfsMbr
     {
         readonly string[] testfiles =
         {
@@ -89,7 +89,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("NTFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/NWFS386.cs b/DiscImageChef.Tests/Filesystems/NWFS386.cs
index 2fe7a9e1..8642c7e9 100644
--- a/DiscImageChef.Tests/Filesystems/NWFS386.cs
+++ b/DiscImageChef.Tests/Filesystems/NWFS386.cs
@@ -32,7 +32,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class NWFS386
+    public class Nwfs386
     {
         readonly string[] testfiles = {"netware_3.12.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
                 }
                 Assert.AreNotEqual(-1, part, string.Format("Partition not found on {0}", testfiles[i]));
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("NWFS386", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/OCFS2.cs b/DiscImageChef.Tests/Filesystems/OCFS2.cs
index 86ea5785..e17b4826 100644
--- a/DiscImageChef.Tests/Filesystems/OCFS2.cs
+++ b/DiscImageChef.Tests/Filesystems/OCFS2.cs
@@ -32,7 +32,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class OCFS2
+    public class Ocfs2
     {
         readonly string[] testfiles = {"linux.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
                 }
                 Assert.AreNotEqual(-1, part, string.Format("Partition not found on {0}", testfiles[i]));
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("OCFS2", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/PFS3_RDB.cs b/DiscImageChef.Tests/Filesystems/PFS3_RDB.cs
index 277d5f76..7d1665d2 100644
--- a/DiscImageChef.Tests/Filesystems/PFS3_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/PFS3_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class PFS3_RDB
+    public class Pfs3Rdb
     {
         readonly string[] testfiles = {"uae.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("PFS v3", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/ProDOS_APM.cs b/DiscImageChef.Tests/Filesystems/ProDOS_APM.cs
index 39201b30..a9028bc2 100644
--- a/DiscImageChef.Tests/Filesystems/ProDOS_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/ProDOS_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class ProDOS_APM
+    public class ProdosApm
     {
         readonly string[] testfiles =
         {
@@ -85,7 +85,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("ProDOS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/QNX4.cs b/DiscImageChef.Tests/Filesystems/QNX4.cs
index 4936495d..2fcbdf54 100644
--- a/DiscImageChef.Tests/Filesystems/QNX4.cs
+++ b/DiscImageChef.Tests/Filesystems/QNX4.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class QNX4
+    public class Qnx4
     {
         readonly string[] testfiles =
             {"qnx_4.24_dsdd.img.lz", "qnx_4.24_dshd.img.lz", "qnx_4.24_mf2dd.img.lz", "qnx_4.24_mf2hd.img.lz"};
@@ -65,7 +65,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
-                Filesystem fs = new DiscImageChef.Filesystems.QNX4();
+                Filesystem fs = new QNX4();
                 Partition wholePart = new Partition
                 {
                     Name = "Whole device",
@@ -73,7 +73,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("QNX4 filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/QNX4_MBR.cs b/DiscImageChef.Tests/Filesystems/QNX4_MBR.cs
index c3e2f170..cdc00828 100644
--- a/DiscImageChef.Tests/Filesystems/QNX4_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/QNX4_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class QNX4_MBR
+    public class Qnx4Mbr
     {
         readonly string[] testfiles = {"qnx_4.24.vdi.lz"};
 
@@ -62,7 +62,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 List<Partition> partitions = Core.Partitions.GetAll(image);
-                Filesystem fs = new DiscImageChef.Filesystems.QNX4();
+                Filesystem fs = new QNX4();
                 int part = -1;
                 for(int j = 0; j < partitions.Count; j++)
                     if(partitions[j].Type == "0x4D")
@@ -73,7 +73,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("QNX4 filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/ReFS_MBR.cs b/DiscImageChef.Tests/Filesystems/ReFS_MBR.cs
index 07e24754..006dda32 100644
--- a/DiscImageChef.Tests/Filesystems/ReFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/ReFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class ReFS_MBR
+    public class ReFsMbr
     {
         readonly string[] testfiles = {"win10.vdi.lz"};
 
@@ -81,7 +81,7 @@ namespace DiscImageChef.Tests.Filesystems
                 /*
                 Filesystem fs = new DiscImageChef.Filesystems.ReFS();
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("ReFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/Reiser3.cs b/DiscImageChef.Tests/Filesystems/Reiser3.cs
index 3115b9a3..89756b25 100644
--- a/DiscImageChef.Tests/Filesystems/Reiser3.cs
+++ b/DiscImageChef.Tests/Filesystems/Reiser3.cs
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(reiserversion[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/Reiser4.cs b/DiscImageChef.Tests/Filesystems/Reiser4.cs
index 7526eed4..780e6176 100644
--- a/DiscImageChef.Tests/Filesystems/Reiser4.cs
+++ b/DiscImageChef.Tests/Filesystems/Reiser4.cs
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("Reiser 4 filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/SFS_MBR.cs b/DiscImageChef.Tests/Filesystems/SFS_MBR.cs
index 1f3daf7e..edc7ee81 100644
--- a/DiscImageChef.Tests/Filesystems/SFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/SFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class SFS_MBR
+    public class SfsMbr
     {
         readonly string[] testfiles = {"aros.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("SmartFileSystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/SFS_MBR_RDB.cs b/DiscImageChef.Tests/Filesystems/SFS_MBR_RDB.cs
index dd45dfa1..a1f9c3d6 100644
--- a/DiscImageChef.Tests/Filesystems/SFS_MBR_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/SFS_MBR_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class SFS_MBR_RDB
+    public class SfsMbrRdb
     {
         readonly string[] testfiles = {"aros.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("SmartFileSystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/SFS_RDB.cs b/DiscImageChef.Tests/Filesystems/SFS_RDB.cs
index 729dd1b0..6f8ce6c9 100644
--- a/DiscImageChef.Tests/Filesystems/SFS_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/SFS_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class SFS_RDB
+    public class SfsRdb
     {
         readonly string[] testfiles = {"uae.vdi.lz", "aros.vdi.lz", "amigaos_4.0.vdi.lz", "amigaos_4.0_sfs2.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("SmartFileSystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/SysV.cs b/DiscImageChef.Tests/Filesystems/SysV.cs
index 5cd3bf0c..a90ebb97 100644
--- a/DiscImageChef.Tests/Filesystems/SysV.cs
+++ b/DiscImageChef.Tests/Filesystems/SysV.cs
@@ -88,7 +88,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/SysV_MBR.cs b/DiscImageChef.Tests/Filesystems/SysV_MBR.cs
index 3ad02aff..bb115713 100644
--- a/DiscImageChef.Tests/Filesystems/SysV_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/SysV_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class SysV_MBR
+    public class SysVMbr
     {
         readonly string[] testfiles =
             {"att_unix_svr4v2.1.vdi.lz", "att_unix_svr4v2.1_2k.vdi.lz", "scoopenserver_5.0.7hw.vdi.lz"};
@@ -80,7 +80,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/SysV_RDB.cs b/DiscImageChef.Tests/Filesystems/SysV_RDB.cs
index 2669712a..6fa26e25 100644
--- a/DiscImageChef.Tests/Filesystems/SysV_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/SysV_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class SysV_RDB
+    public class SysVRdb
     {
         readonly string[] testfiles = {"amix.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UDF.cs b/DiscImageChef.Tests/Filesystems/UDF.cs
index 866a380a..30728256 100644
--- a/DiscImageChef.Tests/Filesystems/UDF.cs
+++ b/DiscImageChef.Tests/Filesystems/UDF.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UDF
+    public class Udf
     {
         readonly string[] testfiles =
         {
@@ -105,7 +105,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(true, image.OpenImage(filter), testfiles[i]);
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
-                Filesystem fs = new DiscImageChef.Filesystems.UDF();
+                Filesystem fs = new UDF();
                 Partition wholePart = new Partition
                 {
                     Name = "Whole device",
@@ -113,7 +113,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(udfversion[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS.cs b/DiscImageChef.Tests/Filesystems/UFS.cs
index 7150506c..a9880986 100644
--- a/DiscImageChef.Tests/Filesystems/UFS.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS
+    public class Ufs
     {
         readonly string[] testfiles =
         {
@@ -86,7 +86,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS_APM.cs b/DiscImageChef.Tests/Filesystems/UFS_APM.cs
index 20f3b154..4967a3f3 100644
--- a/DiscImageChef.Tests/Filesystems/UFS_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS_APM
+    public class UfsApm
     {
         readonly string[] testfiles =
         {
@@ -87,7 +87,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS_MBR.cs b/DiscImageChef.Tests/Filesystems/UFS_MBR.cs
index 027687d0..b3765d6e 100644
--- a/DiscImageChef.Tests/Filesystems/UFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS_MBR
+    public class UfsMbr
     {
         readonly string[] testfiles =
         {
@@ -122,7 +122,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS_NeXT.cs b/DiscImageChef.Tests/Filesystems/UFS_NeXT.cs
index 84dfbaa5..44018718 100644
--- a/DiscImageChef.Tests/Filesystems/UFS_NeXT.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS_NeXT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS_NeXT
+    public class UfsNeXt
     {
         readonly string[] testfiles =
         {
@@ -83,7 +83,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS_NeXT_Floppy.cs b/DiscImageChef.Tests/Filesystems/UFS_NeXT_Floppy.cs
index e5490496..c26ccb45 100644
--- a/DiscImageChef.Tests/Filesystems/UFS_NeXT_Floppy.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS_NeXT_Floppy.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS_NeXT_Floppy
+    public class UfsNeXtFloppy
     {
         readonly string[] testfiles =
         {
@@ -85,7 +85,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS_RDB.cs b/DiscImageChef.Tests/Filesystems/UFS_RDB.cs
index 6b10def1..16864f88 100644
--- a/DiscImageChef.Tests/Filesystems/UFS_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS_RDB
+    public class UfsRdb
     {
         readonly string[] testfiles = {"amix.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UFS_Suni86.cs b/DiscImageChef.Tests/Filesystems/UFS_Suni86.cs
index c794a1d7..0ddd8a97 100644
--- a/DiscImageChef.Tests/Filesystems/UFS_Suni86.cs
+++ b/DiscImageChef.Tests/Filesystems/UFS_Suni86.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UFS_Suni86
+    public class UfsSuni86
     {
         readonly string[] testfiles = {"solaris_7.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UNIXBFS.cs b/DiscImageChef.Tests/Filesystems/UNIXBFS.cs
index df9e01dc..46821e92 100644
--- a/DiscImageChef.Tests/Filesystems/UNIXBFS.cs
+++ b/DiscImageChef.Tests/Filesystems/UNIXBFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class unixbfs
+    public class Unixbfs
     {
         readonly string[] testfiles =
         {
@@ -81,7 +81,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("BFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UNIXBFS_MBR.cs b/DiscImageChef.Tests/Filesystems/UNIXBFS_MBR.cs
index 0030a345..f4861fb4 100644
--- a/DiscImageChef.Tests/Filesystems/UNIXBFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/UNIXBFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class unixbfs_mbr
+    public class UnixbfsMbr
     {
         readonly string[] testfiles = {"linux.vdi.lz"};
 
@@ -75,7 +75,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("BFS", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/UNIXBFS_RDB.cs b/DiscImageChef.Tests/Filesystems/UNIXBFS_RDB.cs
index c58000d6..c3626fa0 100644
--- a/DiscImageChef.Tests/Filesystems/UNIXBFS_RDB.cs
+++ b/DiscImageChef.Tests/Filesystems/UNIXBFS_RDB.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class UNIXBFS_RDB
+    public class UnixbfsRdb
     {
         readonly string[] testfiles = {"amix.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/XENIX.cs b/DiscImageChef.Tests/Filesystems/XENIX.cs
index 779696d2..7f9e34b0 100644
--- a/DiscImageChef.Tests/Filesystems/XENIX.cs
+++ b/DiscImageChef.Tests/Filesystems/XENIX.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class XENIX
+    public class Xenix
     {
         readonly string[] testfiles =
         {
@@ -83,7 +83,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/XENIX_MBR.cs b/DiscImageChef.Tests/Filesystems/XENIX_MBR.cs
index d103d258..732baf63 100644
--- a/DiscImageChef.Tests/Filesystems/XENIX_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/XENIX_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class XENIX_MBR
+    public class XenixMbr
     {
         readonly string[] testfiles = {"xenix_2.3.2d.vdi.lz", "xenix_2.3.4h.vdi.lz", "scoopenserver_5.0.7hw.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(type[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/XFS_MBR.cs b/DiscImageChef.Tests/Filesystems/XFS_MBR.cs
index 056ffd1a..99de81b1 100644
--- a/DiscImageChef.Tests/Filesystems/XFS_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/XFS_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class XFS_MBR
+    public class XfsMbr
     {
         readonly string[] testfiles = {"linux.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("XFS filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/ZFS.cs b/DiscImageChef.Tests/Filesystems/ZFS.cs
index 17c89c24..37f02041 100644
--- a/DiscImageChef.Tests/Filesystems/ZFS.cs
+++ b/DiscImageChef.Tests/Filesystems/ZFS.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class ZFS
+    public class Zfs
     {
         readonly string[] testfiles = {"netbsd_7.1.vdi.lz"};
 
@@ -64,7 +64,7 @@ namespace DiscImageChef.Tests.Filesystems
                 Assert.AreEqual(true, image.OpenImage(filter), testfiles[i]);
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
-                Filesystem fs = new DiscImageChef.Filesystems.ZFS();
+                Filesystem fs = new ZFS();
                 Partition wholePart = new Partition
                 {
                     Name = "Whole device",
@@ -72,7 +72,7 @@ namespace DiscImageChef.Tests.Filesystems
                     Size = image.ImageInfo.Sectors * image.ImageInfo.SectorSize
                 };
                 Assert.AreEqual(true, fs.Identify(image, wholePart), testfiles[i]);
-                fs.GetInformation(image, wholePart, out string information);
+                fs.GetInformation(image, wholePart, out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("ZFS filesystem", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/btrfs.cs b/DiscImageChef.Tests/Filesystems/btrfs.cs
index 532aa724..c6f421e9 100644
--- a/DiscImageChef.Tests/Filesystems/btrfs.cs
+++ b/DiscImageChef.Tests/Filesystems/btrfs.cs
@@ -38,7 +38,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class btrfs
+    public class Btrfs
     {
         readonly string[] testfiles = {"linux.vdi.lz"};
 
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("B-tree file system", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/exFAT_APM.cs b/DiscImageChef.Tests/Filesystems/exFAT_APM.cs
index 023b496e..a7b34e51 100644
--- a/DiscImageChef.Tests/Filesystems/exFAT_APM.cs
+++ b/DiscImageChef.Tests/Filesystems/exFAT_APM.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class exFAT_APM
+    public class ExFatApm
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("exFAT", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/exFAT_GPT.cs b/DiscImageChef.Tests/Filesystems/exFAT_GPT.cs
index 4a256aca..64365db1 100644
--- a/DiscImageChef.Tests/Filesystems/exFAT_GPT.cs
+++ b/DiscImageChef.Tests/Filesystems/exFAT_GPT.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class exFAT_GPT
+    public class ExFatGpt
     {
         readonly string[] testfiles = {"macosx_10.11.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("exFAT", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/exFAT_MBR.cs b/DiscImageChef.Tests/Filesystems/exFAT_MBR.cs
index a814122d..bf4e69ac 100644
--- a/DiscImageChef.Tests/Filesystems/exFAT_MBR.cs
+++ b/DiscImageChef.Tests/Filesystems/exFAT_MBR.cs
@@ -37,7 +37,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class exFAT_MBR
+    public class ExFatMbr
     {
         readonly string[] testfiles = {"linux.vdi.lz", "macosx_10.11.vdi.lz", "win10.vdi.lz", "winvista.vdi.lz"};
 
@@ -77,7 +77,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual("exFAT", fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filesystems/ext2.cs b/DiscImageChef.Tests/Filesystems/ext2.cs
index e2fc71cb..281228d0 100644
--- a/DiscImageChef.Tests/Filesystems/ext2.cs
+++ b/DiscImageChef.Tests/Filesystems/ext2.cs
@@ -38,7 +38,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filesystems
 {
     [TestFixture]
-    public class ext2
+    public class Ext2
     {
         readonly string[] testfiles =
         {
@@ -89,7 +89,7 @@ namespace DiscImageChef.Tests.Filesystems
 
                 Assert.AreNotEqual(-1, part, $"Partition not found on {testfiles[i]}");
                 Assert.AreEqual(true, fs.Identify(image, partitions[part]), testfiles[i]);
-                fs.GetInformation(image, partitions[part], out string information);
+                fs.GetInformation(image, partitions[part], out _);
                 Assert.AreEqual(clusters[i], fs.XmlFSType.Clusters, testfiles[i]);
                 Assert.AreEqual(clustersize[i], fs.XmlFSType.ClusterSize, testfiles[i]);
                 Assert.AreEqual(extversion[i], fs.XmlFSType.Type, testfiles[i]);
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleDave.cs b/DiscImageChef.Tests/Filters/AppleDoubleDave.cs
index a5d93b9c..6aceaacc 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleDave.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleDave.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleDave
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -55,13 +55,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -98,8 +98,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -115,8 +115,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleDos.cs b/DiscImageChef.Tests/Filters/AppleDoubleDos.cs
index aa4be484..c9d26290 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleDos.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleDos.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleDos
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -54,13 +54,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -97,8 +97,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -114,8 +114,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleNetatalk.cs b/DiscImageChef.Tests/Filters/AppleDoubleNetatalk.cs
index 2892014f..94ca3345 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleNetatalk.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleNetatalk.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleNetatalk
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -55,13 +55,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -98,8 +98,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -115,8 +115,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleOsX.cs b/DiscImageChef.Tests/Filters/AppleDoubleOsX.cs
index 455e11fb..4f8e6df7 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleOsX.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleOsX.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleOsX
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -54,13 +54,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -97,8 +97,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -114,8 +114,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleProDos.cs b/DiscImageChef.Tests/Filters/AppleDoubleProDos.cs
index bf405181..656f0e6e 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleProDos.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleProDos.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleProDos
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -54,13 +54,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -97,8 +97,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -114,8 +114,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleUnAr.cs b/DiscImageChef.Tests/Filters/AppleDoubleUnAr.cs
index e296c068..b79e6ef3 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleUnAr.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleUnAr.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleUnAr
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -54,13 +54,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -97,8 +97,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -114,8 +114,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleDoubleUnix.cs b/DiscImageChef.Tests/Filters/AppleDoubleUnix.cs
index c7b81209..30b810a7 100644
--- a/DiscImageChef.Tests/Filters/AppleDoubleUnix.cs
+++ b/DiscImageChef.Tests/Filters/AppleDoubleUnix.cs
@@ -36,10 +36,10 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleDoubleUnix
     {
-        const string ExpectedFile = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedSidecar = "7b0c25bf8cb70f6fb1a15eca31585250";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_SIDECAR = "7b0c25bf8cb70f6fb1a15eca31585250";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
         readonly string sidecar;
 
@@ -54,13 +54,13 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
 
             ctx = new Md5Context();
             ctx.Init();
-            result = ctx.File(sidecar, out tmp);
-            Assert.AreEqual(ExpectedSidecar, result);
+            result = ctx.File(sidecar, out _);
+            Assert.AreEqual(EXPECTED_SIDECAR, result);
         }
 
         [Test]
@@ -97,8 +97,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -114,8 +114,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/AppleSingle.cs b/DiscImageChef.Tests/Filters/AppleSingle.cs
index 77a94ab5..98b30adc 100644
--- a/DiscImageChef.Tests/Filters/AppleSingle.cs
+++ b/DiscImageChef.Tests/Filters/AppleSingle.cs
@@ -36,9 +36,9 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class AppleSingle
     {
-        const string ExpectedFile = "7497a3b156dcd0c1046a1ab12e188ab7";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "7497a3b156dcd0c1046a1ab12e188ab7";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
 
         public AppleSingle()
@@ -51,8 +51,8 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
         }
 
         [Test]
@@ -89,8 +89,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -106,8 +106,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/MacBinary1.cs b/DiscImageChef.Tests/Filters/MacBinary1.cs
index e23f3855..e32f3471 100644
--- a/DiscImageChef.Tests/Filters/MacBinary1.cs
+++ b/DiscImageChef.Tests/Filters/MacBinary1.cs
@@ -36,9 +36,9 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class MacBinary1
     {
-        const string ExpectedFile = "596c38555bc7ba284648d1ce57700884";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "596c38555bc7ba284648d1ce57700884";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
 
         public MacBinary1()
@@ -51,8 +51,8 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
         }
 
         [Test]
@@ -89,8 +89,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -106,8 +106,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/MacBinary2.cs b/DiscImageChef.Tests/Filters/MacBinary2.cs
index b0f09ebc..65db0a44 100644
--- a/DiscImageChef.Tests/Filters/MacBinary2.cs
+++ b/DiscImageChef.Tests/Filters/MacBinary2.cs
@@ -36,9 +36,9 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class MacBinary2
     {
-        const string ExpectedFile = "a8daa55a65432353e95dc4c61d42660f";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "a8daa55a65432353e95dc4c61d42660f";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
 
         public MacBinary2()
@@ -51,8 +51,8 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
         }
 
         [Test]
@@ -89,8 +89,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -106,8 +106,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/MacBinary3.cs b/DiscImageChef.Tests/Filters/MacBinary3.cs
index ab8e470a..b75efaaa 100644
--- a/DiscImageChef.Tests/Filters/MacBinary3.cs
+++ b/DiscImageChef.Tests/Filters/MacBinary3.cs
@@ -36,9 +36,9 @@ namespace DiscImageChef.Tests.Filters
     [TestFixture]
     public class MacBinary3
     {
-        const string ExpectedFile = "3a7363a6109fb52a264b0b45dfa16694";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "a972d27c44193a7587b21416c0953cc3";
+        const string EXPECTED_FILE = "3a7363a6109fb52a264b0b45dfa16694";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "a972d27c44193a7587b21416c0953cc3";
         readonly string location;
 
         public MacBinary3()
@@ -51,8 +51,8 @@ namespace DiscImageChef.Tests.Filters
         {
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.File(location, out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+            string result = ctx.File(location, out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
         }
 
         [Test]
@@ -89,8 +89,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
@@ -106,8 +106,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/PCExchange.cs b/DiscImageChef.Tests/Filters/PCExchange.cs
index 5bf6db36..98717760 100644
--- a/DiscImageChef.Tests/Filters/PCExchange.cs
+++ b/DiscImageChef.Tests/Filters/PCExchange.cs
@@ -34,14 +34,14 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filters
 {
     [TestFixture]
-    public class PCExchange
+    public class PcExchange
     {
-        const string ExpectedFile = "348825a08fa84766d20b91ed917012b9";
-        const string ExpectedContents = "c2be571406cf6353269faa59a4a8c0a4";
-        const string ExpectedResource = "5cb168d60ce8b2b1b3133c2faaf47165";
+        const string EXPECTED_FILE = "348825a08fa84766d20b91ed917012b9";
+        const string EXPECTED_CONTENTS = "c2be571406cf6353269faa59a4a8c0a4";
+        const string EXPECTED_RESOURCE = "5cb168d60ce8b2b1b3133c2faaf47165";
         readonly string location;
 
-        public PCExchange()
+        public PcExchange()
         {
             location = Path.Combine(Consts.TestFilesRoot, "filters", "pcexchange", "DC6_RW_DOS_720.img");
         }
@@ -52,21 +52,21 @@ namespace DiscImageChef.Tests.Filters
             Md5Context ctx = new Md5Context();
             ctx.Init();
             string result = ctx.File(Path.Combine(Consts.TestFilesRoot, "filters", "pcexchange", "FINDER.DAT"),
-                                     out byte[] tmp);
-            Assert.AreEqual(ExpectedFile, result);
+                                     out _);
+            Assert.AreEqual(EXPECTED_FILE, result);
         }
 
         [Test]
         public void CheckFilterId()
         {
-            Filter filter = new DiscImageChef.Filters.PCExchange();
+            Filter filter = new PCExchange();
             Assert.AreEqual(true, filter.Identify(location));
         }
 
         [Test]
         public void Test()
         {
-            Filter filter = new DiscImageChef.Filters.PCExchange();
+            Filter filter = new PCExchange();
             filter.Open(location);
             Assert.AreEqual(true, filter.IsOpened());
             Assert.AreEqual(737280, filter.GetDataForkLength());
@@ -80,7 +80,7 @@ namespace DiscImageChef.Tests.Filters
         [Test]
         public void CheckContents()
         {
-            Filter filter = new DiscImageChef.Filters.PCExchange();
+            Filter filter = new PCExchange();
             filter.Open(location);
             Stream str = filter.GetDataForkStream();
             byte[] data = new byte[737280];
@@ -90,14 +90,14 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedContents, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_CONTENTS, result);
         }
 
         [Test]
         public void CheckResource()
         {
-            Filter filter = new DiscImageChef.Filters.PCExchange();
+            Filter filter = new PCExchange();
             filter.Open(location);
             Stream str = filter.GetResourceForkStream();
             byte[] data = new byte[546];
@@ -107,8 +107,8 @@ namespace DiscImageChef.Tests.Filters
             filter.Close();
             Md5Context ctx = new Md5Context();
             ctx.Init();
-            string result = ctx.Data(data, out byte[] tmp);
-            Assert.AreEqual(ExpectedResource, result);
+            string result = ctx.Data(data, out _);
+            Assert.AreEqual(EXPECTED_RESOURCE, result);
         }
     }
 }
\ No newline at end of file
diff --git a/DiscImageChef.Tests/Filters/XZ.cs b/DiscImageChef.Tests/Filters/XZ.cs
index 0aa8865a..7cc3b113 100644
--- a/DiscImageChef.Tests/Filters/XZ.cs
+++ b/DiscImageChef.Tests/Filters/XZ.cs
@@ -34,7 +34,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Filters
 {
     [TestFixture]
-    public class XZ
+    public class Xz
     {
         static readonly byte[] ExpectedFile =
             {0x6c, 0x88, 0xa5, 0x9a, 0x1b, 0x7a, 0xec, 0x59, 0x2b, 0xef, 0x8a, 0x28, 0xdb, 0x11, 0x01, 0xc8};
@@ -42,7 +42,7 @@ namespace DiscImageChef.Tests.Filters
             {0x18, 0x90, 0x5a, 0xf9, 0x83, 0xd8, 0x2b, 0xdd, 0x1a, 0xcc, 0x69, 0x75, 0x4f, 0x0f, 0x81, 0x5e};
         readonly string location;
 
-        public XZ()
+        public Xz()
         {
             location = Path.Combine(Consts.TestFilesRoot, "filters", "xz.xz");
         }
@@ -59,14 +59,14 @@ namespace DiscImageChef.Tests.Filters
         [Test]
         public void CheckFilterId()
         {
-            Filter filter = new DiscImageChef.Filters.XZ();
+            Filter filter = new XZ();
             Assert.AreEqual(true, filter.Identify(location));
         }
 
         [Test]
         public void Test()
         {
-            Filter filter = new DiscImageChef.Filters.XZ();
+            Filter filter = new XZ();
             filter.Open(location);
             Assert.AreEqual(true, filter.IsOpened());
             Assert.AreEqual(1048576, filter.GetDataForkLength());
@@ -80,7 +80,7 @@ namespace DiscImageChef.Tests.Filters
         [Test]
         public void CheckContents()
         {
-            Filter filter = new DiscImageChef.Filters.XZ();
+            Filter filter = new XZ();
             filter.Open(location);
             Stream str = filter.GetDataForkStream();
             byte[] data = new byte[1048576];
diff --git a/DiscImageChef.Tests/Images/2MG.cs b/DiscImageChef.Tests/Images/2MG.cs
index e38ad28d..70b634ea 100644
--- a/DiscImageChef.Tests/Images/2MG.cs
+++ b/DiscImageChef.Tests/Images/2MG.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Images
 {
     [TestFixture]
-    public class Apple2MG
+    public class Apple2Mg
     {
         readonly string[] testfiles =
         {
@@ -54,7 +54,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.DOS_35_HD
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "7db5d585270ab858043d50e60068d45f", "c62ee4dac8835f9acc999e7531d3b5f8", "86bc7879bb477917aab3976057a6a7b2",
             "32b8f8163238d4f3ea2a3db95ad1a812", "a5acba4cbaddd9c53ea0e8210f4aba55", "eb9b60c78b30d2b6541ed0781944b6da"
@@ -68,14 +68,14 @@ namespace DiscImageChef.Tests.Images
                 string location = Path.Combine(Consts.TestFilesRoot, "images", "2mg", testfiles[i]);
                 Filter filter = new LZip();
                 filter.Open(location);
-                ImagePlugin image = new Apple2Mg();
+                ImagePlugin image = new DiscImages.Apple2Mg();
                 Assert.AreEqual(true, image.OpenImage(filter), testfiles[i]);
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -85,10 +85,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -99,7 +99,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Images/Anex86.cs b/DiscImageChef.Tests/Images/Anex86.cs
index 27a74f8a..cf9050bd 100644
--- a/DiscImageChef.Tests/Images/Anex86.cs
+++ b/DiscImageChef.Tests/Images/Anex86.cs
@@ -56,7 +56,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.NEC_525_HD, MediaType.NEC_525_HD, MediaType.NEC_525_HD
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "1c5387e38e58165c517c059e5d48905d", "a84366658c1c3bd09af4d0d42fbf716e", "919c9eecf1b65b10870f617cb976668a",
             "02d35af02581afb2e56792dcaba2c1af", "b8c3f858f1a9d300d3e74f36eea04354", "c348bbbaf99fcb8c8e66de157aef62f4",
@@ -79,7 +79,7 @@ namespace DiscImageChef.Tests.Images
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -89,10 +89,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -103,7 +103,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Images/CisCopy.cs b/DiscImageChef.Tests/Images/CisCopy.cs
index 3e478868..2afd416b 100644
--- a/DiscImageChef.Tests/Images/CisCopy.cs
+++ b/DiscImageChef.Tests/Images/CisCopy.cs
@@ -67,7 +67,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.DOS_35_HD
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "95c0b76419c1c74db6dbe1d790f97dde", "95c0b76419c1c74db6dbe1d790f97dde", "6f6507e416b7320d583dc347b8e57844",
             "48b93e8619c4c13f4a3724b550e4b371", "48b93e8619c4c13f4a3724b550e4b371", "1d060d2e2543e1c2e8569f5451660060",
@@ -93,7 +93,7 @@ namespace DiscImageChef.Tests.Images
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -103,10 +103,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -117,7 +117,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Images/CopyQM.cs b/DiscImageChef.Tests/Images/CopyQM.cs
index 7ac41213..bbda61d5 100644
--- a/DiscImageChef.Tests/Images/CopyQM.cs
+++ b/DiscImageChef.Tests/Images/CopyQM.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Images
 {
     [TestFixture]
-    public class CopyQM
+    public class CopyQm
     {
         readonly string[] testfiles =
         {
@@ -55,7 +55,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.DMF, MediaType.DMF
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "de3f85896f771b7e5bc4c9e3926d64e4", "c533488a21098a62c85f1649abda2803", "1ff7649b679ba22ff20d39ff717dbec8",
             "b4a602f67903c46eef62addb0780aa56", "b4a602f67903c46eef62addb0780aa56", "03c2af6a8ebf4bd6f530335de34ae5dd",
@@ -70,14 +70,14 @@ namespace DiscImageChef.Tests.Images
                 string location = Path.Combine(Consts.TestFilesRoot, "images", "copyqm", testfiles[i]);
                 Filter filter = new LZip();
                 filter.Open(location);
-                ImagePlugin image = new CopyQm();
+                ImagePlugin image = new DiscImages.CopyQm();
                 Assert.AreEqual(true, image.OpenImage(filter), testfiles[i]);
                 Assert.AreEqual(sectors[i], image.ImageInfo.Sectors, testfiles[i]);
                 Assert.AreEqual(sectorsize[i], image.ImageInfo.SectorSize, testfiles[i]);
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -87,10 +87,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -101,7 +101,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Images/D88.cs b/DiscImageChef.Tests/Images/D88.cs
index 9b3263d6..62d110ac 100644
--- a/DiscImageChef.Tests/Images/D88.cs
+++ b/DiscImageChef.Tests/Images/D88.cs
@@ -69,7 +69,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.NEC_525_HD, MediaType.Unknown, MediaType.NEC_525_HD, MediaType.NEC_525_SS
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "a4103c39cd7fd9fc3de8418dfcf22364", "b948048c03e0b3d34d77f5c9dced0b41", "f91152fab791d4dc0677a289d90478a5",
             "39b01df04a6312b09f1b83c9f3a46b22", "ef775ec1f41b8b725ea83ec8c5ca04e2", "5c2b22f824524cd6c539aaeb2ecb84cd",
@@ -95,7 +95,7 @@ namespace DiscImageChef.Tests.Images
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -105,10 +105,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -119,7 +119,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Images/DART.cs b/DiscImageChef.Tests/Images/DART.cs
index 708a6dbf..ae2e43dc 100644
--- a/DiscImageChef.Tests/Images/DART.cs
+++ b/DiscImageChef.Tests/Images/DART.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Images
 {
     [TestFixture]
-    public class DART
+    public class Dart
     {
         readonly string[] testfiles =
         {
@@ -54,7 +54,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.AppleSonyDS, MediaType.AppleSonyDS, MediaType.AppleSonyDS, MediaType.AppleSonyDS
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "eae3a95671d077deb702b3549a769f56", "eae3a95671d077deb702b3549a769f56", "c5d92544c3e78b7f0a9b4baaa9a64eec",
             "c5d92544c3e78b7f0a9b4baaa9a64eec", "a99744348a70b62b57bce2dec9132ced", "a99744348a70b62b57bce2dec9132ced",
@@ -76,7 +76,7 @@ namespace DiscImageChef.Tests.Images
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -86,10 +86,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -100,7 +100,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Images/DiskCopy42.cs b/DiscImageChef.Tests/Images/DiskCopy42.cs
index e055f0bd..476d7457 100644
--- a/DiscImageChef.Tests/Images/DiskCopy42.cs
+++ b/DiscImageChef.Tests/Images/DiskCopy42.cs
@@ -70,7 +70,7 @@ namespace DiscImageChef.Tests.Images
             MediaType.DOS_35_DS_DD_9, MediaType.AppleSonyDS
         };
 
-        readonly string[] md5s =
+        readonly string[] md5S =
         {
             "eae3a95671d077deb702b3549a769f56", "c5d92544c3e78b7f0a9b4baaa9a64eec", "a99744348a70b62b57bce2dec9132ced",
             "93e71b9ecdb39d3ec9245b4f451856d4", "3160038ca028ccf52ad7863790072145", "5e255c4bc0f6a26ecd27845b37e65aaa",
@@ -96,7 +96,7 @@ namespace DiscImageChef.Tests.Images
                 Assert.AreEqual(mediatypes[i], image.ImageInfo.MediaType, testfiles[i]);
 
                 // How many sectors to read at once
-                const uint sectorsToRead = 256;
+                const uint SECTORS_TO_READ = 256;
                 ulong doneSectors = 0;
 
                 Md5Context ctx = new Md5Context();
@@ -106,10 +106,10 @@ namespace DiscImageChef.Tests.Images
                 {
                     byte[] sector;
 
-                    if(image.ImageInfo.Sectors - doneSectors >= sectorsToRead)
+                    if(image.ImageInfo.Sectors - doneSectors >= SECTORS_TO_READ)
                     {
-                        sector = image.ReadSectors(doneSectors, sectorsToRead);
-                        doneSectors += sectorsToRead;
+                        sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
+                        doneSectors += SECTORS_TO_READ;
                     }
                     else
                     {
@@ -120,7 +120,7 @@ namespace DiscImageChef.Tests.Images
                     ctx.Update(sector);
                 }
 
-                Assert.AreEqual(md5s[i], ctx.End(), testfiles[i]);
+                Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
             }
         }
     }
diff --git a/DiscImageChef.Tests/Partitions/BSD.cs b/DiscImageChef.Tests/Partitions/BSD.cs
index cad9e088..0845b7ec 100644
--- a/DiscImageChef.Tests/Partitions/BSD.cs
+++ b/DiscImageChef.Tests/Partitions/BSD.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class BSD
+    public class Bsd
     {
         readonly string[] testfiles =
             {"parted.vdi.lz", "netbsd_1.6.vdi.lz", "netbsd_6.1.5.vdi.lz", "netbsd_7.1.vdi.lz"};
diff --git a/DiscImageChef.Tests/Partitions/GPT.cs b/DiscImageChef.Tests/Partitions/GPT.cs
index 5678c8fc..51a5f41c 100644
--- a/DiscImageChef.Tests/Partitions/GPT.cs
+++ b/DiscImageChef.Tests/Partitions/GPT.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class GPT
+    public class Gpt
     {
         readonly string[] testfiles = {"linux.vdi.lz", "parted.vdi.lz"};
 
diff --git a/DiscImageChef.Tests/Partitions/MBR.cs b/DiscImageChef.Tests/Partitions/MBR.cs
index d294c672..bcb22c6a 100644
--- a/DiscImageChef.Tests/Partitions/MBR.cs
+++ b/DiscImageChef.Tests/Partitions/MBR.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class MBR
+    public class Mbr
     {
         readonly string[] testfiles =
         {
diff --git a/DiscImageChef.Tests/Partitions/MINIX.cs b/DiscImageChef.Tests/Partitions/MINIX.cs
index 8118783f..0e562288 100644
--- a/DiscImageChef.Tests/Partitions/MINIX.cs
+++ b/DiscImageChef.Tests/Partitions/MINIX.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class MINIX
+    public class Minix
     {
         readonly string[] testfiles = {"minix_3.1.2a.vdi.lz"};
 
diff --git a/DiscImageChef.Tests/Partitions/PC98.cs b/DiscImageChef.Tests/Partitions/PC98.cs
index 80333e82..20ec0eaf 100644
--- a/DiscImageChef.Tests/Partitions/PC98.cs
+++ b/DiscImageChef.Tests/Partitions/PC98.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class PC98
+    public class Pc98
     {
         readonly string[] testfiles =
             {"msdos330.thd.lz", "msdos330_alt.thd.lz", "msdos500_epson.thd.lz", "msdos500.thd.lz", "msdos620.thd.lz"};
diff --git a/DiscImageChef.Tests/Partitions/RDB.cs b/DiscImageChef.Tests/Partitions/RDB.cs
index a1b4a323..69ff8713 100644
--- a/DiscImageChef.Tests/Partitions/RDB.cs
+++ b/DiscImageChef.Tests/Partitions/RDB.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class RDB
+    public class Rdb
     {
         readonly string[] testfiles = {"amigaos_3.9.vdi.lz", "amigaos_4.0.vdi.lz", "parted.vdi.lz"};
 
diff --git a/DiscImageChef.Tests/Partitions/SGI.cs b/DiscImageChef.Tests/Partitions/SGI.cs
index 3eac7aa8..9c4d6acc 100644
--- a/DiscImageChef.Tests/Partitions/SGI.cs
+++ b/DiscImageChef.Tests/Partitions/SGI.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class SGI
+    public class Sgi
     {
         readonly string[] testfiles = {"linux.vdi.lz", "parted.vdi.lz"};
 
diff --git a/DiscImageChef.Tests/Partitions/VTOC.cs b/DiscImageChef.Tests/Partitions/VTOC.cs
index c76fa9d4..af41389d 100644
--- a/DiscImageChef.Tests/Partitions/VTOC.cs
+++ b/DiscImageChef.Tests/Partitions/VTOC.cs
@@ -36,7 +36,7 @@ using NUnit.Framework;
 namespace DiscImageChef.Tests.Partitions
 {
     [TestFixture]
-    public class VTOC
+    public class Vtoc
     {
         readonly string[] testfiles = {"att_unix_vtoc.vdi.lz"};