Пример #1
0
        public void reading_off_same_instance_gives_most_up_to_date_info()
        {
            var checkSum = new MemoryMappedFileCheckpoint(Filename);

            checkSum.Write(0xDEAD);
            checkSum.Flush();
            var read = checkSum.Read();

            checkSum.Close();
            Assert.AreEqual(0xDEAD, read);
        }
        public void the_new_value_is_not_accessible_if_not_flushed_even_with_delay()
        {
            var checkSum     = new MemoryMappedFileCheckpoint(Filename);
            var readChecksum = new MemoryMappedFileCheckpoint(Filename);

            checkSum.Write(1011);
            Thread.Sleep(200);
            Assert.AreEqual(0, readChecksum.Read());
            checkSum.Close();
            readChecksum.Close();
        }
Пример #3
0
        public async Task the_new_value_is_accessible_after_flush()
        {
            var checkSum     = new MemoryMappedFileCheckpoint(Filename);
            var readChecksum = new MemoryMappedFileCheckpoint(Filename);

            checkSum.Write(1011);
            checkSum.Flush();
            Assert.AreEqual(1011, readChecksum.Read());
            checkSum.Close();
            readChecksum.Close();
            await Task.Delay(100);
        }
Пример #4
0
        public void can_read_existing_checksum()
        {
            var checksum = new MemoryMappedFileCheckpoint(Filename);

            checksum.Write(0xDEAD);
            checksum.Close();
            checksum = new MemoryMappedFileCheckpoint(Filename);
            var val = checksum.Read();

            checksum.Close();
            Assert.AreEqual(0xDEAD, val);
        }
        public void the_new_value_is_accessible_after_flush()
        {
            var checkSum     = new MemoryMappedFileCheckpoint(Filename);
            var readChecksum = new MemoryMappedFileCheckpoint(Filename);

            checkSum.Write(1011);
            checkSum.Flush();
            Assert.AreEqual(1011, readChecksum.Read());
            checkSum.Close();
            readChecksum.Close();
            Thread.Sleep(100);
        }
        public void mem_mapped_file_checkpoint_can_be_read_as_file_checkpoint()
        {
            var memoryMapped = new MemoryMappedFileCheckpoint(Filename);

            memoryMapped.Write(0xDEAD);
            memoryMapped.Flush();
            memoryMapped.Dispose();

            var fileCheckpoint = new FileCheckpoint(Filename);
            var read           = fileCheckpoint.Read();

            fileCheckpoint.Dispose();
            Assert.AreEqual(0xDEAD, read);
        }
        private static string CreateExistingDatabase(Action <ICheckpoint, TFChunkWriter> runScenario)
        {
            var databasePath = $"{nameof(StreamRevisionGreaterThanIntMaxValueFixture)}-{Guid.NewGuid():n}";

            var bus          = new InMemoryBus("bus");
            var ioDispatcher = new IODispatcher(bus, new PublishEnvelope(bus));

            if (!Directory.Exists(databasePath))
            {
                Directory.CreateDirectory(databasePath);
            }

            var writerCheckFilename = Path.Combine(databasePath, Checkpoint.Writer + ".chk");
            var chaserCheckFilename = Path.Combine(databasePath, Checkpoint.Chaser + ".chk");
            var writerCheckpoint    = new MemoryMappedFileCheckpoint(writerCheckFilename, Checkpoint.Writer, cached: true);
            var chaserCheckpoint    = new MemoryMappedFileCheckpoint(chaserCheckFilename, Checkpoint.Chaser, cached: true);

            var db = new TFChunkDb(CreateDbConfig(databasePath, writerCheckpoint, chaserCheckpoint,
                                                  TFConsts.ChunkSize));

            db.Open();

            // create DB
            var writer = new TFChunkWriter(db);

            writer.Open();
            runScenario(writerCheckpoint, writer);

            writer.Close();
            writerCheckpoint.Flush();
            chaserCheckpoint.Write(writerCheckpoint.Read());
            chaserCheckpoint.Flush();
            db.Close();

            return(databasePath);
        }