Database validation

Px.Utils.TestingApp/Commands/BenchmarkRunner.cs

@@ -14,6 +14,7 @@ internal BenchmarkRunner()
             _benchmarks.Add("data-validation", new DataValidationBenchmark());
             _benchmarks.Add("file-validation", new PxFileValidationBenchmark());
             _benchmarks.Add("computation", new ComputationBenchmark());
+            _benchmarks.Add("database-validation", new DatabaseValidationBenchmark());
         }
 
         internal override string Help

Px.Utils.TestingApp/Commands/DataValidationBenchmark.cs

@@ -53,17 +53,17 @@ private void ValidateDataBenchmarks()
         {
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
             stream.Position = start + dataKeyword.Length + readStartOffset; // skip the '=' and linechange
-            DataValidator validator = new(stream, expectedCols, expectedRows, TestFilePath, 0, encoding);
-            validator.Validate();
+            DataValidator validator = new(expectedCols, expectedRows, 0);
+            validator.Validate(stream, TestFilePath, encoding);
         }
 
         private async Task ValidateDataBenchmarksAsync()
         {
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
             stream.Position = start + dataKeyword.Length + readStartOffset; // skip the '=' and linechange
-            DataValidator validator = new(stream, expectedCols, expectedRows, TestFilePath, 0, encoding);
+            DataValidator validator = new(expectedCols, expectedRows, 0);
 
-            await validator.ValidateAsync();
+            await validator.ValidateAsync(stream, TestFilePath, encoding);
         }
 
         protected override void SetRunParameters()

Px.Utils.TestingApp/Commands/DatabaseValidationBenchmark.cs

@@ -0,0 +1,69 @@
+using Px.Utils.Validation.DatabaseValidation;
+
+namespace Px.Utils.TestingApp.Commands
+{
+    internal sealed class DatabaseValidationBenchmark : Benchmark
+    {
+        internal override string Help => "Validates a px path database.";
+
+        internal override string Description => "Validates a px path database.";
+        private static readonly string[] directoryFlags = ["-d", "-directory"];
+
+        private DatabaseValidator validator;
+
+        internal DatabaseValidationBenchmark()
+        {
+            ParameterFlags.Add(directoryFlags);
+            BenchmarkFunctions = [ValidationBenchmark];
+            BenchmarkFunctionsAsync = [ValidationBenchmarkAsync];
+        }
+
+        protected override void SetRunParameters()
+        {
+            foreach (string key in directoryFlags)
+            {
+                if (Parameters.TryGetValue(key, out List<string>? value) && value.Count == 1)
+                {
+                    TestFilePath = value[0];
+                    base.SetRunParameters();
+                    return;
+                }
+            }
+
+            throw new ArgumentException("Directory not found.");
+        }
+
+        protected override void StartInteractiveMode()
+        {
+            base.StartInteractiveMode();
+
+            Console.WriteLine("Enter the path to the PX database root to benchmark");
+            string path = Console.ReadLine() ?? "";
+
+            while (!Directory.Exists(path))
+            {
+                Console.WriteLine("Path provided is not valid, please enter a path to a valid directory.");
+                path = Console.ReadLine() ?? "";
+            }
+
+            TestFilePath = path;
+        }
+
+        protected override void OneTimeBenchmarkSetup()
+        {
+            base.OneTimeBenchmarkSetup();
+
+            validator = new(TestFilePath, new LocalFileSystem());
+        }
+
+        private void ValidationBenchmark()
+        {
+            validator.Validate();
+        }
+
+        private async Task ValidationBenchmarkAsync()
+        {
+            await validator.ValidateAsync();
+        }
+    }
+}

Px.Utils.TestingApp/Commands/FileBenchmark.cs

@@ -21,7 +21,7 @@ protected override void SetRunParameters()
                 }
             }
 
-            throw new ArgumentException("File path parameter not found for a file based benchmark.");
+            StartInteractiveMode();
         }
 
         protected override void StartInteractiveMode()

Px.Utils.TestingApp/Commands/MetadataContentValidationBenchmark.cs

@@ -26,8 +26,8 @@ protected override void OneTimeBenchmarkSetup()
 
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
             stream.Seek(0, SeekOrigin.Begin);
-            SyntaxValidator syntaxValidator = new(stream, Encoding.Default, TestFilePath);
-            SyntaxValidationResult validatorResult = syntaxValidator.Validate();
+            SyntaxValidator syntaxValidator = new();
+            SyntaxValidationResult validatorResult = syntaxValidator.Validate(stream, TestFilePath, Encoding.Default);
             _entries = validatorResult.Result;
         }
 

Px.Utils.TestingApp/Commands/MetadataSyntaxValidationBenchmark.cs

@@ -4,7 +4,7 @@
 
 namespace Px.Utils.TestingApp.Commands
 {
-    internal sealed class MetadataSyntaxValidationBenchmark : Benchmark
+    internal sealed class MetadataSyntaxValidationBenchmark : FileBenchmark
     {
         internal override string Help =>
         "Validates the syntax of the Px file metadata given amount of times." + Environment.NewLine +
@@ -13,8 +13,7 @@ internal sealed class MetadataSyntaxValidationBenchmark : Benchmark
 
         internal override string Description => "Benchmarks the metadata syntax validation of Px.Utils/Validation/SyntaxValidator.";
 
-        private Encoding encoding;
-        private SyntaxValidator validator;
+        private Encoding encoding = Encoding.Default;
 
         internal MetadataSyntaxValidationBenchmark()
         {             
@@ -29,24 +28,22 @@ protected override void OneTimeBenchmarkSetup()
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
             PxFileMetadataReader reader = new();
             encoding = reader.GetEncoding(stream);
-            stream.Seek(0, SeekOrigin.Begin);
-            validator = new(stream, encoding, TestFilePath);
         }
 
         private void SyntaxValidationBenchmark()
         {
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
-            stream.Seek(0, SeekOrigin.Begin);
-
-            validator.Validate();
+            SyntaxValidator validator = new();
+            validator.Validate(stream, TestFilePath, encoding);
+            stream.Close();
         }
 
         private async Task SyntaxValidationBenchmarkAsync()
         {
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
-            stream.Seek(0, SeekOrigin.Begin);
-
-            await validator.ValidateAsync();
+            SyntaxValidator validator = new();
+            await validator.ValidateAsync(stream, TestFilePath, encoding);
+            stream.Close();
         }
     }
 }

Px.Utils.TestingApp/Commands/PxFileValidationBenchmark.cs

@@ -1,10 +1,11 @@
-using Px.Utils.PxFile.Metadata;
+using Px.Utils.Exceptions;
+using Px.Utils.PxFile.Metadata;
 using Px.Utils.Validation;
 using System.Text;
 
 namespace Px.Utils.TestingApp.Commands
 {
-    internal class PxFileValidationBenchmark : Benchmark
+    internal sealed class PxFileValidationBenchmark : FileBenchmark
     {
         internal override string Help =>
         "Runs through the whole px file validation process (metadata syntax- and contents-, data-) for the given file.";
@@ -26,21 +27,29 @@ protected override void OneTimeBenchmarkSetup()
 
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
             PxFileMetadataReader reader = new();
-            encoding = reader.GetEncoding(stream);
+            try
+            {
+                encoding = reader.GetEncoding(stream);
+            }
+            catch (InvalidPxFileMetadataException)
+            {
+                encoding = Encoding.Default;
+                throw;
+            }
         }
 
         private void ValidatePxFileBenchmarks()
         {
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
-            PxFileValidator validator = new(stream, TestFilePath, encoding);
-            validator.Validate();
+            PxFileValidator validator = new();
+            validator.Validate(stream, TestFilePath, encoding);
         }
 
         private async Task ValidatePxFileBenchmarksAsync()
         {
             using Stream stream = new FileStream(TestFilePath, FileMode.Open, FileAccess.Read);
-            PxFileValidator validator = new(stream, TestFilePath, encoding);
-            await validator.ValidateAsync();
+            PxFileValidator validator = new();
+            await validator.ValidateAsync(stream, TestFilePath, encoding);
         }
     }
 }

Px.Utils.UnitTests/PxFileTests/DataTests/PxFileStreamDataReaderTests/AsyncDataReaderTests.cs

@@ -165,7 +165,7 @@ public async Task CancelReadDoubleDataValuesAsyncValidIntegersIsCancelled()
             DataIndexer indexer = new(testMeta, matrixMap);
 
             using CancellationTokenSource cts = new();
-            cts.Cancel();
+            await cts.CancelAsync();
             CancellationToken cToken = cts.Token;
 
             async Task call() => await reader.ReadDoubleDataValuesAsync(targetBuffer, 0, indexer, cToken);
@@ -224,7 +224,7 @@ public async Task CancelReadAddDecimalDataValuesAsyncValidIntegersIsCancelled()
             DataIndexer indexer = new(testMeta, matrixMap);
 
             using CancellationTokenSource cts = new();
-            cts.Cancel();
+            await cts.CancelAsync();
             CancellationToken cToken = cts.Token;
 
             async Task call() => await reader.ReadDecimalDataValuesAsync(targetBuffer, 0, indexer, cToken);
@@ -283,7 +283,7 @@ public async Task CancelReadUnsafeDoubleValuesAsyncValidIntegersIsCancelled()
             DataIndexer indexer = new(testMeta, matrixMap);
 
             using CancellationTokenSource cts = new();
-            cts.Cancel();
+            await cts.CancelAsync();
             CancellationToken cToken = cts.Token;
 
             // Act and Assert