public void CheckFileEventsReceiving() { var filesToTest = TestFilesProvider.GetValidFiles( f => f.GetTrackChunks().Count() == 1, f => (TimeSpan)f.GetDuration <MetricTimeSpan>() < TimeSpan.FromSeconds(30)) .Take(5) .ToArray(); for (var i = 0; i < filesToTest.Length; i++) { var file = filesToTest[i]; var tempoMap = file.GetTempoMap(); var eventsToSend = new List <EventToSend>(); var currentTime = TimeSpan.Zero; foreach (var timedEvent in file.GetTimedEvents().Where(e => !(e.Event is MetaEvent))) { var time = (TimeSpan)timedEvent.TimeAs <MetricTimeSpan>(tempoMap); var eventToSend = new EventToSend(timedEvent.Event, time - currentTime); currentTime = time; eventsToSend.Add(eventToSend); } SendReceiveUtilities.CheckEventsReceiving(eventsToSend); } }
private void CheckEventCallback( ICollection <EventToSend> eventsToSend, ICollection <ReceivedEvent> expectedReceivedEvents, TimeSpan changeCallbackAfter, EventCallback eventCallback, EventCallback secondEventCallback) { var playbackContext = new PlaybackContext(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap); var notesStarted = new List <Note>(); var notesFinished = new List <Note>(); using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice)) { playback.NotesPlaybackStarted += (_, e) => notesStarted.AddRange(e.Notes); playback.NotesPlaybackFinished += (_, e) => notesFinished.AddRange(e.Notes); playback.EventCallback = eventCallback; using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); playback.Start(); SpinWait.SpinUntil(() => stopwatch.Elapsed >= changeCallbackAfter); playback.EventCallback = secondEventCallback; var timeout = TimeSpan.FromTicks(eventsToSend.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay; var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, timeout); Assert.IsTrue(playbackStopped, "Playback is running after completed."); } } } CompareReceivedEvents(receivedEvents, expectedReceivedEvents.ToList()); }
public void CheckEventsReceiving_AllEventTypes_ExceptSysEx() { var events = TypesProvider.GetAllEventTypes() .Where(t => !typeof(MetaEvent).IsAssignableFrom(t) && !typeof(SysExEvent).IsAssignableFrom(t)) .Select(t => (MidiEvent)Activator.CreateInstance(t)) .ToArray(); CollectionAssert.IsNotEmpty(events, "Events collection is empty."); SendReceiveUtilities.CheckEventsReceiving(events.Select(e => new EventToSend(e, TimeSpan.Zero)).ToArray()); }
private void CheckTrackControlValueWithOutputDevice( ICollection <EventToSend> eventsToSend, ICollection <EventToSend> eventsWillBeSent, TimeSpan moveFrom, TimeSpan moveTo) { var playbackContext = new PlaybackContext(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap); var notes = eventsForPlayback.GetNotes().ToArray(); using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice)) { playback.TrackControlValue = true; using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); playback.Start(); SpinWait.SpinUntil(() => stopwatch.Elapsed >= moveFrom); playback.MoveToTime((MetricTimeSpan)moveTo); var timeout = TimeSpan.FromTicks(eventsWillBeSent.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == eventsWillBeSent.Count, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); stopwatch.Stop(); var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay); Assert.IsTrue(playbackStopped, "Playback is running after completed."); } } } CompareSentReceivedEvents(sentEvents, receivedEvents, eventsWillBeSent.ToList()); }
public void SaveRecordingToFile() { var tempoMap = TempoMap.Default; var eventsToSend = new[] { new EventToSend(new NoteOnEvent(), TimeSpan.Zero), new EventToSend(new NoteOffEvent(), TimeSpan.FromMilliseconds(500)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)40), TimeSpan.FromSeconds(5)), new EventToSend(new ActiveSensingEvent(), TimeSpan.FromMilliseconds(100)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)50), TimeSpan.FromMilliseconds(500)), }; using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { var receivedEventsNumber = 0; inputDevice.StartEventsListening(); inputDevice.EventReceived += (_, __) => receivedEventsNumber++; using (var recording = new Recording(tempoMap, inputDevice)) { var sendingThread = new Thread(() => { SendReceiveUtilities.SendEvents(eventsToSend, outputDevice); }); recording.Start(); sendingThread.Start(); SpinWait.SpinUntil(() => !sendingThread.IsAlive && receivedEventsNumber == eventsToSend.Length); recording.Stop(); var midiFile = recording.ToFile(); var timedEvents = midiFile.GetTimedEvents(); var expectedEvents = new[] { new TimedEvent(new NoteOnEvent(), TimeConverter.ConvertFrom((MetricTimeSpan)TimeSpan.Zero, tempoMap)), new TimedEvent(new NoteOffEvent(), TimeConverter.ConvertFrom((MetricTimeSpan)TimeSpan.FromMilliseconds(500), tempoMap)), new TimedEvent(new ProgramChangeEvent((SevenBitNumber)40), TimeConverter.ConvertFrom((MetricTimeSpan)TimeSpan.FromSeconds(5.5), tempoMap)), new TimedEvent(new ProgramChangeEvent((SevenBitNumber)50), TimeConverter.ConvertFrom((MetricTimeSpan)TimeSpan.FromSeconds(6.1), tempoMap)) }; Assert.IsTrue( TimedEventEquality.AreEqual(expectedEvents, timedEvents, false, 10), "Timed events saved incorrectly."); } } } }
private static void CheckEventsReceiving(IReadOnlyList <EventToSend> eventsToSend) { var receivedEventsB = new List <ReceivedEvent>(); var receivedEventsC = new List <ReceivedEvent>(); var sentEvents = new List <SentEvent>(); var stopwatch = new Stopwatch(); using (var outputA = OutputDevice.GetByName(MidiDevicesNames.DeviceA)) { SendReceiveUtilities.WarmUpDevice(outputA); outputA.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var inputB = InputDevice.GetByName(MidiDevicesNames.DeviceB)) using (var inputC = InputDevice.GetByName(MidiDevicesNames.DeviceC)) { inputB.EventReceived += (_, e) => receivedEventsB.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); inputB.StartEventsListening(); inputC.EventReceived += (_, e) => receivedEventsC.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); inputC.StartEventsListening(); using (var inputA = InputDevice.GetByName(MidiDevicesNames.DeviceA)) { inputA.StartEventsListening(); using (var outputB = OutputDevice.GetByName(MidiDevicesNames.DeviceB)) using (var outputC = OutputDevice.GetByName(MidiDevicesNames.DeviceC)) { var devicesConnector = inputA.Connect(outputB, outputC); Assert.IsTrue(devicesConnector.AreDevicesConnected, "Devices aren't connected."); stopwatch.Start(); SendReceiveUtilities.SendEvents(eventsToSend, outputA); stopwatch.Stop(); var timeout = TimeSpan.FromTicks(eventsToSend.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil( () => receivedEventsB.Count == eventsToSend.Count && receivedEventsC.Count == eventsToSend.Count, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); devicesConnector.Disconnect(); Assert.IsFalse(devicesConnector.AreDevicesConnected, "Devices aren't disconnected."); } } } } SendReceiveUtilities.CompareSentReceivedEvents(eventsToSend, sentEvents, receivedEventsB, MaximumEventSendReceiveDelay); SendReceiveUtilities.CompareSentReceivedEvents(eventsToSend, sentEvents, receivedEventsC, MaximumEventSendReceiveDelay); }
public void CheckEventsReceiving() { SendReceiveUtilities.CheckEventsReceiving(new[] { new EventToSend(new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)20) { Channel = (FourBitNumber)5 }, TimeSpan.Zero), new EventToSend(new NormalSysExEvent(new byte[] { 1, 2, 3, 0xF7 }), TimeSpan.FromSeconds(1)), new EventToSend(new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)10) { Channel = (FourBitNumber)5 }, TimeSpan.FromSeconds(2)), new EventToSend(new NormalSysExEvent(new byte[] { 4, 5, 6, 0xF7 }), TimeSpan.FromSeconds(2)), new EventToSend(new SongSelectEvent((SevenBitNumber)20), TimeSpan.Zero), new EventToSend(new TuneRequestEvent(), TimeSpan.FromMilliseconds(200)), }); }
public void CheckMidiTimeCodeEventReceiving() { MidiTimeCode midiTimeCodeReceived = null; var eventsToSend = new[] { new EventToSend(new ProgramChangeEvent((SevenBitNumber)100), TimeSpan.FromMilliseconds(500)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.FramesLsb, (FourBitNumber)1), TimeSpan.FromSeconds(1)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)70), TimeSpan.FromMilliseconds(500)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.FramesMsb, (FourBitNumber)1), TimeSpan.FromSeconds(2)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.HoursLsb, (FourBitNumber)7), TimeSpan.FromSeconds(1)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.HoursMsbAndTimeCodeType, (FourBitNumber)7), TimeSpan.FromSeconds(2)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)80), TimeSpan.FromMilliseconds(500)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.MinutesLsb, (FourBitNumber)10), TimeSpan.FromSeconds(1)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)10), TimeSpan.FromMilliseconds(500)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)15), TimeSpan.FromMilliseconds(500)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.MinutesMsb, (FourBitNumber)2), TimeSpan.FromSeconds(2)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.SecondsLsb, (FourBitNumber)10), TimeSpan.FromSeconds(1)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)40), TimeSpan.FromMilliseconds(500)), new EventToSend(new MidiTimeCodeEvent(MidiTimeCodeComponent.SecondsMsb, (FourBitNumber)1), TimeSpan.FromSeconds(2)) }; using (var outputDevice = OutputDevice.GetByName(MidiDevicesNames.DeviceA)) using (var inputDevice = InputDevice.GetByName(MidiDevicesNames.DeviceA)) { inputDevice.MidiTimeCodeReceived += (_, e) => midiTimeCodeReceived = new MidiTimeCode(e.Format, e.Hours, e.Minutes, e.Seconds, e.Frames); inputDevice.StartEventsListening(); SendReceiveUtilities.SendEvents(eventsToSend, outputDevice); var timeout = TimeSpan.FromTicks(eventsToSend.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay; var isMidiTimeCodeReceived = SpinWait.SpinUntil(() => midiTimeCodeReceived != null, timeout); Assert.IsTrue(isMidiTimeCodeReceived, $"MIDI time code received for timeout {timeout}."); inputDevice.StopEventsListening(); } Assert.AreEqual(MidiTimeCodeType.Thirty, midiTimeCodeReceived.Format, "Format is invalid."); Assert.AreEqual(23, midiTimeCodeReceived.Hours, "Hours number is invalid."); Assert.AreEqual(42, midiTimeCodeReceived.Minutes, "Minutes number is invalid."); Assert.AreEqual(26, midiTimeCodeReceived.Seconds, "Seconds number is invalid."); Assert.AreEqual(17, midiTimeCodeReceived.Frames, "Frames number is invalid."); }
public void GetDuration(TimeSpan start, TimeSpan delayFromStart) { var eventsToSend = new[] { new EventToSend(new NoteOnEvent(), start), new EventToSend(new NoteOffEvent(), delayFromStart) }; var receivedEvents = new List <ReceivedEvent>(); var stopwatch = new Stopwatch(); using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.StartEventsListening(); inputDevice.EventReceived += (_, e) => receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); using (var recording = new Recording(TempoMap.Default, inputDevice)) { recording.Start(); stopwatch.Start(); SendReceiveUtilities.SendEvents(eventsToSend, outputDevice); var timeout = start + delayFromStart + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == eventsToSend.Length, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); recording.Stop(); Assert.IsFalse(recording.IsRunning, "Recording is running after stop."); TimeSpan duration = recording.GetDuration <MetricTimeSpan>(); Assert.IsTrue( AreTimeSpansEqual(duration, start + delayFromStart), $"Duration is invalid. Actual is {duration}. Expected is {start + delayFromStart}."); } } } }
private void CheckPlaybackStop( ICollection <EventToSend> eventsToSend, ICollection <EventToSend> eventsWillBeSent, TimeSpan stopAfter, TimeSpan stopPeriod, PlaybackAction setupPlayback, PlaybackAction afterStart, PlaybackAction afterStop, PlaybackAction afterResume, IEnumerable <Tuple <TimeSpan, PlaybackAction> > runningAfterResume = null, ICollection <TimeSpan> explicitExpectedTimes = null, double speed = 1.0, ICollection <ReceivedEvent> expectedReceivedEvents = null, ICollection <ReceivedEvent> expectedPlayedEvents = null) { var playbackContext = new PlaybackContext(); var playedEvents = new List <ReceivedEvent>(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap); var expectedTimes = playbackContext.ExpectedTimes; if (explicitExpectedTimes != null || expectedReceivedEvents != null || expectedPlayedEvents != null) { expectedTimes.AddRange(explicitExpectedTimes ?? (expectedReceivedEvents?.Select(e => e.Time) ?? expectedPlayedEvents.Select(e => e.Time))); } else { var currentTime = TimeSpan.Zero; foreach (var eventWillBeSent in eventsWillBeSent) { currentTime += eventWillBeSent.Delay; var scaledCurrentTime = ScaleTimeSpan(currentTime, 1.0 / speed); expectedTimes.Add(currentTime > stopAfter ? scaledCurrentTime + stopPeriod : scaledCurrentTime); } } using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice)) { playback.Speed = speed; setupPlayback(playbackContext, playback); if (expectedPlayedEvents != null) { playback.EventPlayed += (_, e) => playedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); playback.Start(); afterStart(playbackContext, playback); SpinWait.SpinUntil(() => stopwatch.Elapsed >= stopAfter); playback.Stop(); afterStop(playbackContext, playback); Thread.Sleep(stopPeriod); playback.Start(); afterResume(playbackContext, playback); if (runningAfterResume != null) { foreach (var check in runningAfterResume) { Thread.Sleep(check.Item1); check.Item2(playbackContext, playback); } } var timeout = expectedTimes.Last() + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == expectedTimes.Count, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); stopwatch.Stop(); var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay); Assert.IsTrue(playbackStopped, "Playback is running after completed."); } } } CompareSentReceivedEvents(sentEvents, receivedEvents, expectedTimes); if (expectedReceivedEvents != null) { CompareReceivedEvents(receivedEvents, expectedReceivedEvents.ToList()); } if (expectedPlayedEvents != null) { CompareReceivedEvents(playedEvents, expectedPlayedEvents.ToList()); } }
private void CheckPlayback( ICollection <EventToSend> eventsToSend, double speed, PlaybackAction beforePlaybackStarted, PlaybackAction startPlayback, PlaybackAction afterPlaybackStarted, PlaybackAction waiting, PlaybackAction finalChecks, CreateTickGeneratorCallback createTickGeneratorCallback = null) { var playbackContext = new PlaybackContext(); var receivedEvents = playbackContext.ReceivedEvents; var sentEvents = playbackContext.SentEvents; var stopwatch = playbackContext.Stopwatch; var tempoMap = playbackContext.TempoMap; var eventsForPlayback = new List <MidiEvent>(); var expectedTimes = playbackContext.ExpectedTimes; var currentTime = TimeSpan.Zero; foreach (var eventToSend in eventsToSend.Where(e => !(e.Event is MetaEvent))) { var midiEvent = eventToSend.Event.Clone(); midiEvent.DeltaTime = LengthConverter.ConvertFrom((MetricTimeSpan)eventToSend.Delay, (MetricTimeSpan)currentTime, tempoMap); currentTime += eventToSend.Delay; eventsForPlayback.Add(midiEvent); expectedTimes.Add(TimeSpan.FromTicks(MathUtilities.RoundToLong(currentTime.Ticks / speed))); } using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); var clockSettings = createTickGeneratorCallback != null ? new MidiClockSettings { CreateTickGeneratorCallback = createTickGeneratorCallback } : null; using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice, clockSettings)) { playback.Speed = speed; beforePlaybackStarted(playbackContext, playback); using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.EventReceived += (_, e) => { lock (playbackContext.ReceivedEventsLockObject) { receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); } }; inputDevice.StartEventsListening(); stopwatch.Start(); startPlayback(playbackContext, playback); afterPlaybackStarted(playbackContext, playback); waiting(playbackContext, playback); stopwatch.Stop(); finalChecks(playbackContext, playback); } } } CompareSentReceivedEvents(sentEvents.Take(expectedTimes.Count).ToList(), receivedEvents.Take(expectedTimes.Count).ToList(), expectedTimes); }
public void PlayRecordedData() { var tempoMap = TempoMap.Default; var eventsToSend = new[] { new EventToSend(new NoteOnEvent(), TimeSpan.Zero), new EventToSend(new NoteOffEvent(), TimeSpan.FromMilliseconds(500)), new EventToSend(new ProgramChangeEvent((SevenBitNumber)40), TimeSpan.FromSeconds(5)) }; MidiFile recordedFile = null; using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { var receivedEventsNumber = 0; inputDevice.StartEventsListening(); inputDevice.EventReceived += (_, __) => receivedEventsNumber++; using (var recording = new Recording(tempoMap, inputDevice)) { var sendingThread = new Thread(() => { SendReceiveUtilities.SendEvents(eventsToSend, outputDevice); }); recording.Start(); sendingThread.Start(); SpinWait.SpinUntil(() => !sendingThread.IsAlive && receivedEventsNumber == eventsToSend.Length); recording.Stop(); recordedFile = recording.ToFile(); } } } CheckPlayback( eventsToSend, 1.0, beforePlaybackStarted: NoPlaybackAction, startPlayback: (context, playback) => playback.Start(), afterPlaybackStarted: NoPlaybackAction, waiting: (context, playback) => { var timeout = context.ExpectedTimes.Last() + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil(() => context.ReceivedEvents.Count == eventsToSend.Length, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); }, finalChecks: (context, playback) => { var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay); Assert.IsTrue(playbackStopped, "Playback is running after completed."); }, createPlayback: (outputDevice, clockSettings) => recordedFile.GetPlayback(outputDevice, clockSettings)); }
public void CheckRecording() { var tempoMap = TempoMap.Default; var stopAfter = TimeSpan.FromSeconds(1); var stopPeriod = TimeSpan.FromSeconds(2); var eventsToSend = new[] { new EventToSend(new NoteOnEvent(), TimeSpan.Zero), new EventToSend(new NoteOffEvent(), TimeSpan.FromMilliseconds(500)), new EventToSend(new TimingClockEvent(), TimeSpan.FromSeconds(5)) }; var sentEvents = new List <SentEvent>(); var receivedEvents = new List <ReceivedEvent>(); var stopwatch = new Stopwatch(); var expectedTimes = new List <TimeSpan>(); var expectedRecordedTimes = new List <TimeSpan>(); var currentTime = TimeSpan.Zero; foreach (var eventToSend in eventsToSend) { currentTime += eventToSend.Delay; expectedTimes.Add(currentTime); expectedRecordedTimes.Add(currentTime > stopAfter ? currentTime - stopPeriod : currentTime); } using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { SendReceiveUtilities.WarmUpDevice(outputDevice); outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed)); using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName)) { inputDevice.StartEventsListening(); inputDevice.EventReceived += (_, e) => receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed)); using (var recording = new Recording(tempoMap, inputDevice)) { var sendingThread = new Thread(() => { SendReceiveUtilities.SendEvents(eventsToSend, outputDevice); }); stopwatch.Start(); recording.Start(); sendingThread.Start(); Thread.Sleep(stopAfter); recording.Stop(); Thread.Sleep(stopPeriod); recording.Start(); var timeout = expectedTimes.Last() + SendReceiveUtilities.MaximumEventSendReceiveDelay; var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == expectedTimes.Count, timeout); Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}."); CompareSentReceivedEvents(sentEvents, receivedEvents, expectedTimes); var recordedEvents = recording.GetEvents(); CheckRecordedEvents(recordedEvents, expectedRecordedTimes, tempoMap); } } } }