public void CaptureReader_Correctly_Assigns_Offsets_To_ICaptureState_Instances_When_Read()
{
var stateController = new WeatherStateController(new WeatherSimulator());
var stateResolver = new StateResolver();
stateResolver.Add(stateController);
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
ms.Position = 0;
var stream = new ConcurrentStream(ms);
var captureStream = new CaptureStream(stream, FileAccess.Read, stateResolver);
var lastOffset = 0d;
for (int i = 0; i < captureStream.Count; i++)
{
var state = captureStream.Read();
Assert.True(state.Offset >= 0);
Assert.True(state.Offset >= lastOffset);
lastOffset = state.Offset;
}
}
public void CaptureStream_Supports_Reading_A_File_For_Playback_Prior_To_The_Entire_File_Becoming_Available()
{
//base bytes to feed into the stream at random
var bytes = VastPark.FrameworkBase.IO.EmbeddedResource.GetBytes("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var endOfHeader = 0L;
using (var ms = new MemoryStream(bytes))
{
var reader = new CaptureReader(new ConcurrentStream(ms), new StateResolver());
endOfHeader = reader.BaseStream.Position;
}
var stream = new MemoryStream();
var baseStream = new ConcurrentStream(stream);
var binaryWriter = new BinaryWriter(stream);
var stateResolver = new StateResolver();
stateResolver.Add(new Continuum.Test.Mock.WeatherStateController(new WeatherSimulator()));
//push in some bytes to get it started, enough for the header so that the stream won't throw on construction
binaryWriter.Write(bytes, 0, (int)endOfHeader);
var offset = baseStream.Position;
baseStream.Position = 0;
var captureStream = new CaptureStream(baseStream, FileAccess.Read, stateResolver);
Assert.Null(captureStream.Peek());
//write some bytes in (not enough for a full state)
binaryWriter.Seek((int)offset, SeekOrigin.Begin);
binaryWriter.Write(bytes, (int)offset, 10);
offset += 10;
Assert.Null(captureStream.Peek());
//write some more bytes so that there is now a full state that can be peeked at
binaryWriter.Seek((int)offset, SeekOrigin.Begin);
binaryWriter.Write(bytes, (int)offset, 200);
Assert.NotNull(captureStream.Peek());
}
public void CaptureStream_Instances_Are_Played_Back_In_Chronological_Order()
{
var resetEvent = new SlimResetEvent(20);
var expectedStates = long.MaxValue;
var executedStates = 0;
var stateController = new WeatherStateController(new WeatherSimulator());
var stateResolver = new StateResolver();
stateResolver.Add(stateController);
stateController.StateExecuted += delegate
{
executedStates++;
if (executedStates == expectedStates)
{
resetEvent.Set();
}
};
var playbackService = new PlaybackService(stateResolver);
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream1 = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream1 = new CaptureStream(stream1, System.IO.FileAccess.Read, stateResolver);
var stream2 = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream2 = new CaptureStream(stream2, System.IO.FileAccess.Read, stateResolver);
expectedStates = captureStream1.Count + captureStream2.Count;
playbackService.Add(captureStream1);
playbackService.Add(captureStream2);
playbackService.Start();
resetEvent.Wait();
}
public void When_A_Filter_Is_Applied_That_Returns_True_The_State_Is_Not_Scheduled_For_Playback()
{
var stateController = new WeatherStateController(new WeatherSimulator());
var stateResolver = new StateResolver();
stateResolver.Add(stateController);
var scheduler = new Mock<IScheduler>();
var taskFactory = new Mock<ITaskFactory>();
var playbackService = new PlaybackService(stateResolver, scheduler.Object, taskFactory.Object);
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, stateResolver);
playbackService.Add(captureStream);
//add in a filter that will always return true to filter out the states
playbackService.Add(new StreamFilter(f => true));
playbackService.Start();
//task factory should not have built any tasks
taskFactory.Verify(t => t.Create(It.IsAny<ICaptureState>()), Times.Never());
scheduler.Verify(s => s.Add(It.IsAny<ITask>()), Times.Never());
}
public void When_A_Codec_Is_Not_Available_An_Event_Is_Raised_With_The_Guid_Of_The_Required_Codec()
{
var stateController = new WeatherStateController(new WeatherSimulator());
var stateResolver = new StateResolver();
stateResolver.Add(stateController);
var playbackService = new PlaybackService(stateResolver);
playbackService.CodecRequired += delegate(object sender, CodecRequiredEventArgs e)
{
Assert.Equal(stateController.Guid, e.Guid);
};
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, stateResolver);
playbackService.Add(captureStream);
}
public void When_A_Codec_Is_Not_Available_An_Event_Is_Raised_Giving_The_Caller_An_Opportunity_To_Acquire_It()
{
var stateController = new WeatherStateController(new WeatherSimulator());
var stateResolver = new StateResolver();
var eventRaised = false;
var playbackService = new PlaybackService(stateResolver);
playbackService.CodecRequired += delegate
{
eventRaised = true;
};
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, stateResolver);
playbackService.Add(captureStream);
Assert.True(eventRaised);
}
public void CaptureReader_Length_Is_Correct_After_Construction()
{
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
ms.Position = 0;
var stream = new ConcurrentStream(ms);
var captureStream = new CaptureStream(stream, FileAccess.Read, new StateResolver());
Assert.NotEqual(TimeSpan.Zero, captureStream.Length);
}
public void Start()
{
//check if any dummy controllers need to be created to satisfy the CaptureStream
foreach (var recorder in _Recorders)
{
if (this.StateResolver.Find(recorder.Guid) == null)
{
var dummyController = new DummyController(recorder.Guid);
this.StateResolver.Add(dummyController);
_DummyControllers.Add(dummyController);
}
}
CaptureStream = new CaptureStream(this.Stream, System.IO.FileAccess.Write, this.StateResolver);
lock (_Lock)
{
var maxDelay = TimeSpan.Zero;
foreach (var recorder in _Recorders)
{
var start = DateTime.Now;
recorder.Start();
var delay = DateTime.Now.Subtract(start);
if (delay > maxDelay)
{
maxDelay = delay;
}
}
_OffsetDelay = maxDelay;
}
this.IsStarted = true;
}
public void Custom_Capture_Formats_Are_Recorded_Correctly()
{
var resetEvent = new SlimResetEvent(20);
var desiredStates = 200;
var generatedStates = 0;
var ms = new MemoryStream();
var stream = new ConcurrentStream(ms);
var weatherSimulator = new WeatherSimulator();
_StateResolver = new StateResolver();
//build the controller that manages weather states
var controller = new WeatherStateController(weatherSimulator);
//watch the simluator for the desired number of states
weatherSimulator.NewTemperature += delegate
{
generatedStates++;
if (generatedStates >= desiredStates)
{
weatherSimulator.Stop();
resetEvent.Set();
}
};
//register it with the capture service
_StateResolver = new StateResolver();
_StateResolver.Add(controller);
//create the capture stream, will create an entry in the SAT for the WeatherStateController
var captureStream = new CaptureStream(stream, FileAccess.Write, _StateResolver);
//pass the controller the stream so that it can be written to
controller.Initialise(captureStream);
//start the simulator, the controller will watch for changes internally
weatherSimulator.Start();
//wait until the event is raised [desiredStates] number of times
resetEvent.Wait();
Assert.Equal(generatedStates, captureStream.Count);
//rewind the stream and open it for reading, verify the values match
stream.Position = 0;
captureStream = new CaptureStream(stream, FileAccess.Read, _StateResolver);
for (int i = 0; i < captureStream.Count; i++)
{
var state = captureStream.Read();
Assert.Equal(weatherSimulator.History[i], (state as WeatherCaptureState).Temperature);
}
}
public void CaptureStream_Supports_Reading_A_File_While_It_Is_Being_Written_From_Another_Thread()
{
//base bytes to feed into the stream at random
var bytes = VastPark.FrameworkBase.IO.EmbeddedResource.GetBytes("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var endOfHeader = 0L;
using(var ms = new MemoryStream(bytes))
{
var reader = new CaptureReader(new ConcurrentStream(ms), new StateResolver());
endOfHeader = reader.BaseStream.Position;
}
var stream = new MemoryStream();
var baseStream = new ConcurrentStream(stream);
var binaryWriter = new BinaryWriter(stream);
var stateResolver = new StateResolver();
stateResolver.Add(new Continuum.Test.Mock.WeatherStateController(new WeatherSimulator()));
//push in some bytes to get it started, enough for the header so that the stream won't throw on construction
binaryWriter.Write(bytes, 0, (int)endOfHeader);
var offset = baseStream.Position;
baseStream.Position = 0;
var captureStream = new CaptureStream(baseStream, FileAccess.Read, stateResolver);
//write in a little more so we don't have a full state yet
binaryWriter.Seek((int)offset, SeekOrigin.Begin);
//binaryWriter.Write(bytes, (int)offset, 5);
//offset += 5;
var readStates = 0;
var lockObject = new object();
//create a thread to randomly write chunks of bytes into the base stream
ThreadPool.QueueUserWorkItem(w =>
{
while (offset < bytes.LongLength)
{
var bytesToWrite = new Random().Next(1, 200);
if (bytesToWrite > bytes.Length - offset)
{
bytesToWrite = Convert.ToInt32(bytes.LongLength - offset);
}
lock (lockObject)
{
binaryWriter.Seek((int)offset, SeekOrigin.Begin);
binaryWriter.Write(bytes, (int)offset, bytesToWrite);
offset += bytesToWrite;
}
Thread.Sleep(200);
}
Assert.Equal(bytes.LongLength, baseStream.Length);
lock (lockObject)
{
binaryWriter.Seek(0, SeekOrigin.Begin);
for (int i = 0; i < bytes.LongLength; i++)
{
Assert.Equal(bytes[i], (byte)baseStream.ReadByte());
}
}
});
while (captureStream.Position < captureStream.Count)
{
lock (lockObject)
{
if (captureStream.Peek() != null)
{
captureStream.Read();
readStates++;
}
}
}
Assert.Equal(captureStream.Count, readStates);
}
public void Selecting_A_Position_When_The_Current_Position_Is_Zero_Will_Read_That_Node()
{
var controller = new WeatherStateController(new WeatherSimulator());
_StateResolver = new StateResolver();
_StateResolver.Add(controller);
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, _StateResolver);
var desiredNode = Math.Round(Convert.ToDouble(captureStream.Count) / 2);
captureStream.Position = (long)desiredNode - 1; //if the desired node is 50, its required to put the stream at position 49 in order to read it
var seekNode = captureStream.Read();
//manually read nodes, when the desired node is reached it should match the node pulled out previously
stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
captureStream = new CaptureStream(stream, FileAccess.Read, _StateResolver);
ICaptureState actualNode = null;
for (int i = 0; i < desiredNode; i++)
{
actualNode = captureStream.Read();
}
Assert.Equal(actualNode.Guid, seekNode.Guid);
Assert.Equal(actualNode.Offset, seekNode.Offset);
Assert.Equal(actualNode.Timestamp, seekNode.Timestamp);
for (int i = 0; i < actualNode.Data.Length; i++)
{
Assert.Equal(actualNode.Data[i], seekNode.Data[i]);
}
}
public void Selecting_A_Position_Forward_In_The_Stream_When_The_Current_Position_Is_Not_Zero_Will_Read_That_Node()
{
_StateResolver = new StateResolver();
var controller = new WeatherStateController(new WeatherSimulator());
_StateResolver.Add(controller);
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, _StateResolver);
var desiredNode = Math.Round(Convert.ToDouble(captureStream.Count) / 2);
//read up the number of nodes to move the position pointer forwards in the stream
for (int i = 0; i < desiredNode; i++)
{
captureStream.Read();
}
//seek to the new position
captureStream.Position += 2;
//this node is equivalent to node desiredNode + 3
var seekNode = captureStream.Read();
//manually read nodes, when the desired node is reached it should match the node pulled out previously
stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
captureStream = new CaptureStream(stream, FileAccess.Read, _StateResolver);
ICaptureState actualNode = null;
for (int i = 0; i < desiredNode + 3; i++)
{
actualNode = captureStream.Read();
}
Assert.Equal(actualNode.Guid, seekNode.Guid);
Assert.Equal(actualNode.Offset, seekNode.Offset);
Assert.Equal(actualNode.Timestamp, seekNode.Timestamp);
for (int i = 0; i < actualNode.Data.Length; i++)
{
Assert.Equal(actualNode.Data[i], seekNode.Data[i]);
}
}
public void Selecting_A_Position_Beyond_The_Length_Of_The_Stream_Will_Throw_An_Exception()
{
_StateResolver = new StateResolver();
var controller = new WeatherStateController(new WeatherSimulator());
_StateResolver.Add(controller);
var ms = VastPark.FrameworkBase.IO.EmbeddedResource.GetMemoryStream("Continuum.Test.Samples.weather-simulation.continuum", Assembly.GetExecutingAssembly());
var stream = new ConcurrentStream(new MemoryStream(ms.ToArray()));
var captureStream = new CaptureStream(stream, System.IO.FileAccess.Read, _StateResolver);
Assert.Throws(typeof(Exception), new Assert.ThrowsDelegate(delegate { captureStream.Position = captureStream.Count + 1; }));
}
public void Position_Is_Updated_Correctly_During_Writes()
{
var count = 100;
var ms = new ConcurrentStream(new MemoryStream());
var validGuids = _GenerateCaptureService(count);
var captureStream = new CaptureStream(ms, FileAccess.Write, _StateResolver);
for (int i = 0; i < count; i++)
{
var mock = new Mock<ICaptureState>();
mock.Setup(p => p.Guid).Returns(validGuids[i]);
mock.Setup(p => p.Data).Returns(Guid.NewGuid().ToByteArray());
captureStream.Write(mock.Object);
Assert.Equal(i + 1, captureStream.Position);
}
}
public void When_Streaming_A_Continuum_File_The_Completion_Event_Is_Not_Raised_While_The_File_Still_Has_More_Data()
{
var captureStream = new CaptureStream(new ConcurrentStream(new MemoryStream()), FileAccess.Write, new StateResolver());
Assert.Equal(TimeSpan.Zero, captureStream.Length);
}
public void Multiple_IStateRecorders_Are_Written_In_Chronological_Order_Into_A_Shared_Stream()
{
var guid = Guid.NewGuid();
var stream = new ConcurrentStream(new MemoryStream());
var stateController = new SimpleStateController { Guid = guid };
var stateResolver = new StateResolver();
stateResolver.Add(stateController);
var captureService = new CaptureService
{
Stream = stream,
StateResolver = stateResolver
};
var recorder1 = new Mock<IStateRecorder>();
var recorder2 = new Mock<IStateRecorder>();
var recorderBuffer1 = new SimpleBuffer<ICaptureState>();
var recorderBuffer2 = new SimpleBuffer<ICaptureState>();
recorder1.Setup(b => b.Buffer).Returns(recorderBuffer1);
recorder2.Setup(b => b.Buffer).Returns(recorderBuffer2);
//push some dummy states into the buffers
var state1 = new Mock<ICaptureState>();
var firstTimestamp = DateTime.Now.AddDays(1);
state1.Setup(s => s.Timestamp).Returns(firstTimestamp);
state1.Setup(s => s.Guid).Returns(guid);
var state2 = new Mock<ICaptureState>();
var secondTimestamp = DateTime.Now.AddDays(2);
state2.Setup(s => s.Timestamp).Returns(secondTimestamp);
state2.Setup(s => s.Guid).Returns(guid);
recorderBuffer1.Enqueue(state1.Object);
recorderBuffer2.Enqueue(state2.Object);
//add the 2nd recorder in first as it's timestamp is at a time in the future beyond the first recorder's state
captureService.Add(recorder2.Object);
captureService.Add(recorder1.Object);
captureService.Start();
captureService.Flush();
Assert.Equal(2, captureService.CaptureStream.Count);
//open the stream for reading now
stream.Position = 0;
var captureStream = new CaptureStream(stream, FileAccess.Read, stateResolver);
//first value read back should be from state1
Assert.Equal(firstTimestamp, captureStream.Read().Timestamp);
Assert.Equal(secondTimestamp, captureStream.Read().Timestamp);
}
public void CaptureStream_Supports_Writing_A_State_And_Then_Reading_It()
{
var stateController = new WeatherStateController(new WeatherSimulator());
var stateResolver = new StateResolver();
stateResolver.Add(stateController);
var baseStream = new ConcurrentStream(new MemoryStream());
var captureStream = new CaptureStream(baseStream, FileAccess.ReadWrite, stateResolver);
Assert.True(captureStream.CanRead);
Assert.True(captureStream.CanWrite);
//write a state then read it back
var expectedBytes = Guid.NewGuid().ToByteArray();
captureStream.Write(new WeatherCaptureState(expectedBytes, stateController.Guid, DateTime.UtcNow, 0));
//the read pointer is still at the start of the stream
var readState = captureStream.Read();
for (int i = 0; i < readState.Data.Length; i++)
{
Assert.Equal(expectedBytes[i], readState.Data[i]);
}
}
