public void CanReadStoredBlockFolder()
        {
            var blk0 = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat"), (uint)1).ToList();
            var blk1 = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0002.dat"), (uint)2).ToList();

            int count = 0;

            foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks")))
            {
                if (count == 0)
                {
                    Assert.Equal(blk0[0].Item.GetHash(), stored.Item.GetHash());
                }
                if (count == 2000)
                {
                    Assert.Equal(blk1[0].Item.GetHash(), stored.Item.GetHash());
                }
                Assert.True(stored.Item.Check());
                count++;
            }
            Assert.Equal(4000, count);

            count = 0;
            foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk1[1998].BlockPosition)))
            {
                count++;
            }
            Assert.Equal(2, count);

            count = 0;
            foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk0[1998].BlockPosition)))
            {
                count++;
            }
            Assert.Equal(2002, count);

            count = 0;
            foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk0[1998].BlockPosition, blk1[2].BlockPosition)))
            {
                count++;
            }
            Assert.Equal(4, count);

            count = 0;
            foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk0[30].BlockPosition, blk0[34].BlockPosition)))
            {
                count++;
            }
            Assert.Equal(4, count);
        }
        public void CanStoreInBlockRepository()
        {
            var blockRepository = CreateBlockRepository();
            var firstblk1       = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).First();

            blockRepository.WriteBlockHeader(firstblk1.Item.Header);
            var result = blockRepository.GetBlock(firstblk1.Item.GetHash());

            Assert.True(result.HeaderOnly);

            blockRepository.WriteBlock(firstblk1.Item);
            result = blockRepository.GetBlock(firstblk1.Item.GetHash());
            Assert.False(result.HeaderOnly);
        }
        public void CanIndexBlock()
        {
            var index = CreateIndexedStore();

            foreach (var block in StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Take(50))
            {
                index.Put(block.Item);
            }
            var genesis = index.Get(uint256.Parse("0x0000066e91e46e5a264d42c89e1204963b2ee6be230b443e9159020539d972af"));

            Assert.NotNull(genesis);
            var invalidBlock = index.Get(uint256.Parse("0x0000066e91e46e5a264d42c89e1204963b2ee6be230b443e9159020539d972ae"));

            Assert.Null(invalidBlock);
        }
        public void CanStoreBlocksInMultipleFiles()
        {
            var store = CreateBlockStore();

            store.MaxFileSize = 10;             //Verify break all block in one respective file with extreme settings
            var allBlocks = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Take(10).ToList();

            foreach (var s in allBlocks)
            {
                store.Append(s.Item);
            }
            var storedBlocks = store.Enumerate(true).ToList();

            Assert.Equal(allBlocks.Count, storedBlocks.Count);
            Assert.Equal(11, store.Folder.GetFiles().Length);             //10 files + lock file
        }
        public void CanReadStoredBlockFile()
        {
            int count = 0;

            foreach (var stored in StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")))
            {
                Assert.True(stored.Item.Check());
                count++;
            }
            Assert.Equal(2000, count);
            count = 0;
            var twoLast = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Skip(1998).ToList();

            foreach (var stored in StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat"), range: new DiskBlockPosRange(twoLast[0].BlockPosition)))
            {
                count++;
            }
            Assert.Equal(2, count);
        }
        public void CanStoreBlocks()
        {
            var store     = CreateBlockStore();
            var allBlocks = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Take(50).ToList();

            foreach (var s in allBlocks)
            {
                store.Append(s.Item);
            }
            var storedBlocks = store.Enumerate(true).ToList();

            Assert.Equal(allBlocks.Count, storedBlocks.Count);

            foreach (var s in allBlocks)
            {
                var retrieved = store.Enumerate(true).First(b => b.Item.GetHash() == s.Item.GetHash());
                Assert.True(retrieved.Item.HeaderOnly);
            }
        }
 //The last block is off by 1 byte + lots of padding zero at the end
 public void CanEnumerateIncompleteBlk()
 {
     Assert.Equal(300, StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("incompleteblk.dat")).Count());
 }