public void Performance_test()
        {
            var data = new byte[1000];

            for (var i = 0; i < 1000; i++)
            {
                data[i] = (byte)(i % 255);
            }

            var data1 = new byte[2000];

            for (var i = 0; i < 2000; i++)
            {
                data1[i] = (byte)(i % 255);
            }

            using (var storage = new ReliableStorage(new NullProcessor()))
            {
                storage.LoadPersistentData();

                const int count = 10000;
                var       sw    = new Stopwatch();
                sw.Start();
                for (var i = 0; i < count; i++)
                {
                    storage.StoreBlock(data, i.ToString(), 155);
                }

                sw.Stop();

                Console.WriteLine(
                    $"Writing {count} blocks to persistent storage took {sw.ElapsedMilliseconds} milliseconds");
            }


            {
                var w         = new Stopwatch();
                var processor = new NullProcessor();

                w.Start();
                using (var storage = new ReliableStorage(processor))
                {
                    storage.LoadPersistentData();
                }

                w.Stop();

                Console.WriteLine(
                    $"Loading {processor.ProcessedBlocks.Count} blocks from persistent storage took {w.ElapsedMilliseconds} milliseconds");
            }

            using (var storage = new ReliableStorage(new NullProcessor()))
            {
                storage.LoadPersistentData();

                const int count = 10000;
                var       sw    = new Stopwatch();
                sw.Start();
                for (var i = 0; i < count; i++)
                {
                    storage.StoreBlock(data, i.ToString(), 155);
                }

                sw.Stop();

                Console.WriteLine(
                    $"In-place updating {count} blocks to persistent storage took {sw.ElapsedMilliseconds} milliseconds");
            }

            using (var storage = new ReliableStorage(new NullProcessor()))
            {
                storage.LoadPersistentData();

                const int count = 10000;
                var       sw    = new Stopwatch();
                sw.Start();
                for (var i = 0; i < count; i++)
                {
                    storage.StoreBlock(data1, i.ToString(), 155);
                }

                sw.Stop();

                Console.WriteLine(
                    $"out of place updating {count} blocks to persistent storage took {sw.ElapsedMilliseconds} milliseconds");
            }

            {
                var w         = new Stopwatch();
                var processor = new NullProcessor();

                w.Start();
                using (var storage = new ReliableStorage(processor))
                {
                    storage.LoadPersistentData();
                    w.Stop();

                    Assert.AreEqual(10000, storage.InactiveBlockCount);
                }


                Console.WriteLine(
                    $"Loading {processor.ProcessedBlocks.Count} blocks from persistent storage  with dirty blocks took {w.ElapsedMilliseconds} milliseconds");
            }


            var info = new FileInfo(Path.Combine(Constants.DataPath, ReliableStorage.StorageFileName));

            Console.WriteLine($"Before cleaning the file size was {info.Length}");

            // clean the storage (remove all dirty blocks)
            {
                var w         = new Stopwatch();
                var processor = new NullProcessor();


                using (var storage = new ReliableStorage(processor))
                {
                    storage.LoadPersistentData();
                    w.Start();
                    storage.CleanStorage();
                    w.Stop();

                    Assert.AreEqual(0, storage.InactiveBlockCount);

                    Console.WriteLine(
                        $"Storage cleaning took {w.ElapsedMilliseconds} milliseconds");
                }
            }

            info = new FileInfo(Path.Combine(Constants.DataPath, ReliableStorage.StorageFileName));

            Console.WriteLine($"After cleaning the file size was {info.Length}");

            {
                var w         = new Stopwatch();
                var processor = new NullProcessor();

                w.Start();
                using (var storage = new ReliableStorage(processor))
                {
                    storage.LoadPersistentData();
                    w.Stop();

                    Assert.AreEqual(0, storage.InactiveBlockCount);
                }


                Console.WriteLine(
                    $"Loading {processor.ProcessedBlocks.Count} blocks from persistent storage after cleaning took {w.ElapsedMilliseconds} milliseconds");
            }
        }