public void CaptureReader_Can_Read_Back_A_Stream_That_Was_Written_By_A_CaptureWriter() { var writeOperations = 100; var ms = new ConcurrentStream(new MemoryStream()); var sat = new Dictionary<Guid, short>(); sat.Add(Guid.NewGuid(), 24); sat.Add(Guid.NewGuid(), 25); sat.Add(Guid.NewGuid(), 26); var stateResolver = new Mock<IStateResolver>(); stateResolver.SetupGet(s => s.AllocationTable).Returns(sat); stateResolver.Setup(s => s.IsAllocated(It.IsAny<Guid>())).Returns<Guid>(g => sat.ContainsKey(g)); stateResolver.Setup(s => s.GetAllocatedId(It.IsAny<Guid>())).Returns<Guid>(g => sat[g]); //write operations var captureWriter = new CaptureWriter(ms, stateResolver.Object); for (int i = 0; i < writeOperations; i++) { var timestamp = DateTime.UtcNow; var randomData = new byte[1024]; new Random().NextBytes(randomData); var randomSat = (short)new Random().Next(24, 26); var captureState = new Mock<ICaptureState>(); captureState.Setup(c => c.Data).Returns(randomData); captureState.Setup(c => c.Guid).Returns(sat.Where(f => f.Value == randomSat).First().Key); captureState.Setup(c => c.Timestamp).Returns(timestamp); captureWriter.Write(captureState.Object); } //rewind the stream to the beginning ms.Position = 0; //read operations var readStateResolver = new StateResolver(); readStateResolver.Add(new SimpleStateController { Guid = sat.Where(f => f.Value == 24).First().Key }); readStateResolver.Add(new SimpleStateController { Guid = sat.Where(f => f.Value == 25).First().Key }); readStateResolver.Add(new SimpleStateController { Guid = sat.Where(f => f.Value == 26).First().Key }); var captureReader = new CaptureReader(ms, readStateResolver); while (captureReader.Position < captureReader.Count) { captureReader.Read(); } }
/// <summary> /// Creates a new instance of the CaptureStream with the specified base stream and mode /// </summary> /// <param name="stream"></param> public CaptureStream(IStream baseStream, System.IO.FileAccess fileAccess, IStateResolver stateResolver) { switch (fileAccess) { case System.IO.FileAccess.Read: { _CaptureReader = new CaptureReader(baseStream, stateResolver); this.Timestamp = _CaptureReader.Timestamp; break; } case System.IO.FileAccess.Write: { _CaptureWriter = new CaptureWriter(baseStream, stateResolver); this.Timestamp = _CaptureWriter.Timestamp; break; } default: { var streamPosition = baseStream.Position; //important to create writer first, it will create the header the reader expects (if required) _CaptureWriter = new CaptureWriter(baseStream, stateResolver); //put the position back to the original position baseStream.Position = streamPosition; //reader now has a valid continuum file to play _CaptureReader = new CaptureReader(baseStream, stateResolver); this.Timestamp = _CaptureWriter.Timestamp; break; } } this.StateResolver = stateResolver; //store the read/write pointers _ReadPointer = baseStream.Position; _WritePointer = baseStream.Position; _Lock = new object(); }
public void Peek_Does_Not_Advance_The_Read_Pointer() { var writeOperations = 100; var ms = new ConcurrentStream(new MemoryStream()); var sat = new Dictionary<Guid, short>(); sat.Add(Guid.NewGuid(), 24); sat.Add(Guid.NewGuid(), 25); sat.Add(Guid.NewGuid(), 26); var stateResolver = new Mock<IStateResolver>(); stateResolver.SetupGet(s => s.AllocationTable).Returns(sat); stateResolver.Setup(s => s.IsAllocated(It.IsAny<Guid>())).Returns<Guid>(g => sat.ContainsKey(g)); stateResolver.Setup(s => s.GetAllocatedId(It.IsAny<Guid>())).Returns<Guid>(g => sat[g]); //write operations var captureWriter = new CaptureWriter(ms, stateResolver.Object); for (int i = 0; i < writeOperations; i++) { var timestamp = DateTime.UtcNow; var randomData = new byte[1024]; new Random().NextBytes(randomData); var randomSat = (short)new Random().Next(24, 27); var captureState = new Mock<ICaptureState>(); captureState.Setup(c => c.Data).Returns(randomData); captureState.Setup(c => c.Guid).Returns(sat.Where(f => f.Value == randomSat).First().Key); captureState.Setup(c => c.Timestamp).Returns(timestamp); captureWriter.Write(captureState.Object); } //rewind the stream to the beginning ms.Position = 0; //read operations var readStateResolver = new StateResolver(); readStateResolver.Add(new SimpleStateController { Guid = sat.Where(f => f.Value == 24).First().Key }); readStateResolver.Add(new SimpleStateController { Guid = sat.Where(f => f.Value == 25).First().Key }); readStateResolver.Add(new SimpleStateController { Guid = sat.Where(f => f.Value == 26).First().Key }); var captureReader = new CaptureReader(ms, readStateResolver); var position = captureReader.Position; var state = captureReader.Peek(sat.Where(f => f.Value == (short)26).First().Key); Assert.NotNull(state); Assert.Equal(position, captureReader.Position); }
public void CaptureWriter_Inserts_The_Correct_Data_Into_The_Stream_During_Multiple_Write_Operations() { var writeOperations = 100; var ms = new ConcurrentStream(new MemoryStream()); var sat = new Dictionary<Guid, short>(); sat.Add(Guid.NewGuid(), 24); sat.Add(Guid.NewGuid(), 25); sat.Add(Guid.NewGuid(), 26); var stateResolver = new Mock<IStateResolver>(); stateResolver.SetupGet(s => s.AllocationTable).Returns(sat); stateResolver.Setup(s => s.IsAllocated(It.IsAny<Guid>())).Returns<Guid>(g => sat.ContainsKey(g)); stateResolver.Setup(s => s.GetAllocatedId(It.IsAny<Guid>())).Returns<Guid>(g => sat[g]); var captureWriter = new CaptureWriter(ms, stateResolver.Object); for (int i = 0; i < writeOperations; i++) { var timestamp = DateTime.UtcNow; var rewindPosition = ms.Position; var randomData = new byte[1024]; new Random().NextBytes(randomData); var randomSat = (short)new Random().Next(24, 26); var captureState = new Mock<ICaptureState>(); captureState.Setup(c => c.Data).Returns(randomData); captureState.Setup(c => c.Guid).Returns(sat.Where(f => f.Value == randomSat).First().Key); captureState.Setup(c => c.Timestamp).Returns(timestamp); captureWriter.Write(captureState.Object); //rewind the stream and check the correct data length was written ms.Position = rewindPosition + 2 + 8; var dataLengthBuffer = new byte[4]; ms.Read(dataLengthBuffer, 0, 4); var dataLength = BitConverter.ToInt32(dataLengthBuffer, 0); var dataBuffer = new byte[dataLength]; ms.Read(dataBuffer, 0, dataLength); for (int j = 0; j < dataBuffer.Length; j++) { Assert.Equal(randomData[j], dataBuffer[j]); } } }
public void CaptureWriter_Updates_The_Length_Of_The_Stream_During_Writes() { var ms = new ConcurrentStream(new MemoryStream()); var sat = new Dictionary<Guid, short>(); sat.Add(Guid.NewGuid(), 24); sat.Add(Guid.NewGuid(), 25); sat.Add(Guid.NewGuid(), 26); var stateResolver = new Mock<IStateResolver>(); stateResolver.SetupGet(s => s.AllocationTable).Returns(sat); stateResolver.Setup(s => s.IsAllocated(It.IsAny<Guid>())).Returns<Guid>(g => sat.ContainsKey(g)); stateResolver.Setup(s => s.GetAllocatedId(It.IsAny<Guid>())).Returns<Guid>(g => sat[g]); var captureWriter = new CaptureWriter(ms, stateResolver.Object); var lastLength = TimeSpan.Zero; for (int i = 0; i < 20; i++) { var timestamp = DateTime.UtcNow.AddSeconds(i * 10); var randomData = new byte[10000]; new Random().NextBytes(randomData); var captureState = new Mock<ICaptureState>(); captureState.Setup(c => c.Data).Returns(randomData); captureState.Setup(c => c.Guid).Returns(sat.Where(f => f.Value == 24).First().Key); captureState.Setup(c => c.Timestamp).Returns(timestamp); captureWriter.Write(captureState.Object); Assert.True(captureWriter.Length > lastLength); lastLength = captureWriter.Length; } }
public void CaptureWriter_Inserts_The_Correct_Timestamp_Into_The_Stream_During_Write_Operations() { var ms = new ConcurrentStream(new MemoryStream()); var sat = new Dictionary<Guid, short>(); sat.Add(Guid.NewGuid(), 24); sat.Add(Guid.NewGuid(), 25); sat.Add(Guid.NewGuid(), 26); var stateResolver = new Mock<IStateResolver>(); stateResolver.SetupGet(s => s.AllocationTable).Returns(sat); stateResolver.Setup(s => s.IsAllocated(It.IsAny<Guid>())).Returns<Guid>(g => sat.ContainsKey(g)); stateResolver.Setup(s => s.GetAllocatedId(It.IsAny<Guid>())).Returns<Guid>(g => sat[g]); var captureWriter = new CaptureWriter(ms, stateResolver.Object); var timestamp = DateTime.UtcNow; var rewindPosition = ms.Position; var captureState = new Mock<ICaptureState>(); captureState.Setup(c => c.Data).Returns(Guid.NewGuid().ToByteArray()); captureState.Setup(c => c.Guid).Returns(sat.Where(f => f.Value == 24).First().Key); captureState.Setup(c => c.Timestamp).Returns(timestamp); captureWriter.Write(captureState.Object); //rewind the stream and check the correct timestamp was written ms.Position = rewindPosition + 2; var timestampBuffer = new byte[8]; ms.Read(timestampBuffer, 0, 8); Assert.Equal(timestamp, DateTime.FromBinary(BitConverter.ToInt64(timestampBuffer, 0))); }
public void CaptureWriter_Buids_A_Valid_Continuum_Header() { var baseStream = new ConcurrentStream(new MemoryStream()); var stateResolver = new StateResolver(); var stateController = new WeatherStateController(new WeatherSimulator()); stateResolver.Add(stateController); var captureWriter = new CaptureWriter(baseStream, stateResolver); baseStream.Position = 0; byte[] header = new byte[Constants.CONTINUUM_HEADER_SIGNATURE.Length]; baseStream.Read(header, 0, header.Length); for (int i = 0; i < Constants.CONTINUUM_HEADER_SIGNATURE.Length; i++) { Assert.Equal(Constants.CONTINUUM_HEADER_SIGNATURE[i], header[i]); } //dont worry about 4 bytes reserved for version info at the moment baseStream.Position = baseStream.Position + 4; //ignore the timestamp for now baseStream.Position = baseStream.Position + 8; //ignore the count property for now baseStream.Position = baseStream.Position + 8; //ignore the length property for now baseStream.Position = baseStream.Position + 8; //read the SAT, there should be at least one entry for it to be valid //the SAT looks like this: //<lengthOfSac><firstId of type short><delimiter> var lengthOfSatBuffer = new byte[4]; baseStream.Read(lengthOfSatBuffer, 0, lengthOfSatBuffer.Length); var lengthOfSat = BitConverter.ToInt32(lengthOfSatBuffer, 0); Assert.True(lengthOfSat > 0); //read back the sat var readSat = new Dictionary<short, Guid>(); for (int i = 0; i < lengthOfSat; i++) { var idBuffer = new byte[2]; baseStream.Read(idBuffer, 0, idBuffer.Length); var guid = new byte[16]; //guids are 16-bytes baseStream.Read(guid, 0, guid.Length); readSat.Add(BitConverter.ToInt16(idBuffer, 0), new Guid(guid)); } //match the sat foreach (var kvp in stateResolver.AllocationTable) { Assert.True(readSat.ContainsKey(kvp.Value)); Assert.True(readSat[kvp.Value] == kvp.Key); } }