public void SendEvent_MidiEvent()
{
var midiEvent = new NoteOnEvent((SevenBitNumber)45, (SevenBitNumber)89)
{
Channel = (FourBitNumber)6
};
using (var outputDevice = OutputDevice.GetByName(MidiDevicesNames.DeviceA))
{
MidiEvent eventSent = null;
outputDevice.EventSent += (_, e) => eventSent = e.Event;
using (var inputDevice = InputDevice.GetByName(MidiDevicesNames.DeviceA))
{
MidiEvent eventReceived = null;
inputDevice.EventReceived += (_, e) => eventReceived = e.Event;
inputDevice.StartEventsListening();
outputDevice.PrepareForEventsSending();
outputDevice.SendEvent(new NoteOnEvent((SevenBitNumber)45, (SevenBitNumber)89)
{
Channel = (FourBitNumber)6
});
var timeout = TimeSpan.FromMilliseconds(15);
var isEventSentReceived = SpinWait.SpinUntil(() => eventSent != null && eventReceived != null, timeout);
Assert.IsTrue(isEventSentReceived, "Event either not sent ot not received.");
MidiAsserts.AreEventsEqual(midiEvent, eventSent, false, "Sent event is invalid.");
MidiAsserts.AreEventsEqual(eventSent, eventReceived, false, "Received event is invalid.");
}
}
}
public void Write_Compression_DeleteDefaultKeySignature_Obsolete()
{
var nonDefaultKeySignatureEvent = new KeySignatureEvent(-5, 1);
var midiFile = new MidiFile(
new TrackChunk(
new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50),
new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)50),
new UnknownMetaEvent(254),
new KeySignatureEvent(),
nonDefaultKeySignatureEvent));
Write_Compression_Obsolete(
midiFile,
CompressionPolicy.DeleteDefaultKeySignature,
(fileInfo1, fileInfo2) =>
{
var originalMidiFile = MidiFile.Read(fileInfo1.FullName);
Assert.AreEqual(
2,
originalMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <KeySignatureEvent>().Count(),
"Invalid count of Key Signature events in original file.");
var newMidiFile = MidiFile.Read(fileInfo2.FullName);
var keySignatureEvents = newMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <KeySignatureEvent>().ToArray();
Assert.AreEqual(
1,
keySignatureEvents.Length,
"Invalid count of Key Signature events in new file.");
MidiAsserts.AreEventsEqual(keySignatureEvents[0], nonDefaultKeySignatureEvent, false, "Invalid Key Signature event.");
});
}
public void CloneEvent()
{
var random = new Random();
foreach (var type in TypesProvider.GetAllEventTypes())
{
var midiEvent = type == typeof(UnknownMetaEvent)
? new UnknownMetaEvent(1)
: (MidiEvent)Activator.CreateInstance(type);
if (midiEvent is ChannelEvent channelEvent)
{
channelEvent.Channel = (FourBitNumber)(random.Next(5) + 5);
}
if (midiEvent is BaseTextEvent baseTextEvent)
{
baseTextEvent.Text = random.Next(1000).ToString();
}
midiEvent.DeltaTime = random.Next(1000) + 1;
var midiEventClone = midiEvent.Clone();
MidiAsserts.AreEventsEqual(midiEvent, midiEventClone, true, $"Clone of {type} is invalid.");
}
}
public void Write_DeleteDefaultTimeSignature()
{
var nonDefaultTimeSignatureEvent = new TimeSignatureEvent(2, 16);
var midiFile = new MidiFile(
new TrackChunk(
new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50),
new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)50),
new UnknownMetaEvent(254),
new TimeSignatureEvent(),
nonDefaultTimeSignatureEvent));
Write(
midiFile,
settings => settings.DeleteDefaultTimeSignature = true,
(fileInfo1, fileInfo2) =>
{
var originalMidiFile = MidiFile.Read(fileInfo1.FullName);
Assert.AreEqual(
2,
originalMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <TimeSignatureEvent>().Count(),
"Invalid count of Time Signature events in original file.");
var newMidiFile = MidiFile.Read(fileInfo2.FullName);
var timeSignatureEvents = newMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <TimeSignatureEvent>().ToArray();
Assert.AreEqual(
1,
timeSignatureEvents.Length,
"Invalid count of Time Signature events in new file.");
MidiAsserts.AreEventsEqual(timeSignatureEvents[0], nonDefaultTimeSignatureEvent, false, "Invalid Time Signature event.");
});
}
public void AllEventTypesAreReadCorrectly(Func <Type, MidiEvent> createMidiEvent)
{
var events = TypesProvider.GetAllEventTypes()
.Where(t => !typeof(SystemCommonEvent).IsAssignableFrom(t) &&
!typeof(SystemRealTimeEvent).IsAssignableFrom(t) &&
t != typeof(EndOfTrackEvent) &&
t != typeof(UnknownMetaEvent))
.Select(createMidiEvent)
.ToArray();
var midiFile = MidiFileTestUtilities.Read(
new MidiFile(new TrackChunk(events)),
null,
new ReadingSettings {
SilentNoteOnPolicy = SilentNoteOnPolicy.NoteOn
},
MidiFileFormat.SingleTrack);
var readEvents = midiFile.GetEvents().ToArray();
for (var i = 0; i < events.Length; i++)
{
var expectedEvent = events[i];
var actualEvent = readEvents[i];
MidiAsserts.AreEventsEqual(expectedEvent, actualEvent, true, $"Event {i} is invalid.");
}
}
private static void CompareEvents(MidiEvent expectedMidiEvent, MidiEvent actualMidiEvent)
{
MidiAsserts.AreEventsEqual(
expectedMidiEvent,
actualMidiEvent,
false,
"MIDI event read incorrectly.");
}
public void Write_DeleteDefaultKeySignature_DeleteDefaultSetTempo()
{
var nonDefaultKeySignatureEvent = new KeySignatureEvent(-5, 1);
var nonDefaultSetTempoEvent = new SetTempoEvent(100000);
var midiFile = new MidiFile(
new TrackChunk(
new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50),
new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)50),
new UnknownMetaEvent(254),
new KeySignatureEvent(),
nonDefaultKeySignatureEvent,
new SetTempoEvent(),
nonDefaultSetTempoEvent));
Write(
midiFile,
settings =>
{
settings.DeleteDefaultKeySignature = true;
settings.DeleteDefaultSetTempo = true;
},
(fileInfo1, fileInfo2) =>
{
var originalMidiFile = MidiFile.Read(fileInfo1.FullName);
var newMidiFile = MidiFile.Read(fileInfo2.FullName);
//
Assert.AreEqual(
2,
originalMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <KeySignatureEvent>().Count(),
"Invalid count of Key Signature events in original file.");
var keySignatureEvents = newMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <KeySignatureEvent>().ToArray();
Assert.AreEqual(
1,
keySignatureEvents.Length,
"Invalid count of Key Signature events in new file.");
MidiAsserts.AreEventsEqual(keySignatureEvents[0], nonDefaultKeySignatureEvent, false, "Invalid Key Signature event.");
//
Assert.AreEqual(
2,
originalMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <SetTempoEvent>().Count(),
"Invalid count of Set Tempo events in original file.");
var setTempoEvents = newMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <SetTempoEvent>().ToArray();
Assert.AreEqual(
1,
setTempoEvents.Length,
"Invalid count of Set Tempo events in new file.");
MidiAsserts.AreEventsEqual(setTempoEvents[0], nonDefaultSetTempoEvent, false, "Invalid Set Tempo event.");
});
}
public void AllEventTypesAreReadCorrectly()
{
var events = TypesProvider.GetAllEventTypes()
.Where(t => !typeof(SystemCommonEvent).IsAssignableFrom(t) &&
!typeof(SystemRealTimeEvent).IsAssignableFrom(t) &&
t != typeof(EndOfTrackEvent) &&
t != typeof(UnknownMetaEvent))
.Select(t =>
{
var instance = (MidiEvent)Activator.CreateInstance(t);
if (instance is SysExEvent sysExEvent)
{
sysExEvent.Data = new byte[] { 1, 2, 3 }
}
;
if (instance is SequencerSpecificEvent sequencerSpecificEvent)
{
sequencerSpecificEvent.Data = new byte[] { 1, 2, 3 }
}
;
if (instance is NoteOnEvent noteOnEvent)
{
noteOnEvent.Velocity = (SevenBitNumber)100;
}
if (instance is BaseTextEvent baseTextEvent)
{
baseTextEvent.Text = Guid.NewGuid().ToString();
}
return(instance);
})
.ToArray();
var midiFile = MidiFileTestUtilities.Read(new MidiFile(new TrackChunk(events)), null, null, MidiFileFormat.SingleTrack);
var readEvents = midiFile.GetEvents().ToArray();
for (var i = 0; i < events.Length; i++)
{
var expectedEvent = events[i];
var actualEvent = readEvents[i];
MidiAsserts.AreEventsEqual(expectedEvent, actualEvent, true, $"Event {i} is invalid.");
}
}
public void SendEvent(MidiEvent midiEvent)
{
using (var outputDevice = OutputDevice.GetByName(MidiDevicesNames.DeviceA))
{
MidiEvent eventSent = null;
outputDevice.EventSent += (_, e) => eventSent = e.Event;
string errorOnSend = null;
outputDevice.ErrorOccurred += (_, e) => errorOnSend = e.Exception.Message;
using (var inputDevice = InputDevice.GetByName(MidiDevicesNames.DeviceA))
{
MidiEvent eventReceived = null;
inputDevice.EventReceived += (_, e) => eventReceived = e.Event;
string errorOnReceive = null;
inputDevice.ErrorOccurred += (_, e) => errorOnReceive = e.Exception.Message;
inputDevice.StartEventsListening();
outputDevice.PrepareForEventsSending();
outputDevice.SendEvent(midiEvent);
var timeout = TimeSpan.FromMilliseconds(15);
var isEventSentReceived = SpinWait.SpinUntil(() => eventSent != null && eventReceived != null, timeout);
if (!isEventSentReceived)
{
if (errorOnSend != null)
{
Assert.Fail($"Failed to send event: {errorOnSend}");
}
else if (errorOnReceive != null)
{
Assert.Fail($"Failed to receive event: {errorOnReceive}");
}
else
{
Assert.Fail("Event either not sent ot not received.");
}
}
MidiAsserts.AreEventsEqual(midiEvent, eventSent, false, "Sent event is invalid.");
MidiAsserts.AreEventsEqual(eventSent, eventReceived, false, "Received event is invalid.");
}
}
}
private void CompareSentReceivedEvents(
IReadOnlyList <SentEvent> sentEvents,
IReadOnlyList <ReceivedEvent> receivedEvents,
IReadOnlyList <TimeSpan> expectedTimes)
{
for (var i = 0; i < sentEvents.Count; i++)
{
var sentEvent = sentEvents[i];
var receivedEvent = receivedEvents[i];
var expectedTime = expectedTimes[i];
MidiAsserts.AreEventsEqual(sentEvent.Event, receivedEvent.Event, false, $"Received event {receivedEvent.Event} doesn't match sent one {sentEvent.Event}.");
var offsetFromExpectedTime = (sentEvent.Time - expectedTime).Duration();
Assert.LessOrEqual(
offsetFromExpectedTime,
SendReceiveUtilities.MaximumEventSendReceiveDelay,
$"Event was sent at wrong time (at {sentEvent.Time} instead of {expectedTime}).");
}
}
private void CompareReceivedEvents(
IReadOnlyList <ReceivedEvent> receivedEvents,
IReadOnlyList <ReceivedEvent> expectedReceivedEvents)
{
Assert.AreEqual(expectedReceivedEvents.Count, receivedEvents.Count, "Received events count is invalid.");
for (var i = 0; i < receivedEvents.Count; i++)
{
var receivedEvent = receivedEvents[i];
var expectedReceivedEvent = expectedReceivedEvents[i];
MidiAsserts.AreEventsEqual(expectedReceivedEvent.Event, receivedEvent.Event, false, $"Received event {receivedEvent.Event} doesn't match expected one {expectedReceivedEvent.Event}.");
var expectedTime = expectedReceivedEvent.Time;
var offsetFromExpectedTime = (receivedEvent.Time - expectedTime).Duration();
Assert.LessOrEqual(
offsetFromExpectedTime,
SendReceiveUtilities.MaximumEventSendReceiveDelay,
$"Event was received at wrong time (at {receivedEvent.Time} instead of {expectedTime}).");
}
}
public static void CompareSentReceivedEvents(
IReadOnlyList <EventToSend> eventsToSend,
IReadOnlyList <SentEvent> sentEvents,
IReadOnlyList <ReceivedEvent> receivedEvents,
TimeSpan maximumEventSendReceiveDelay)
{
for (var i = 0; i < sentEvents.Count; i++)
{
var eventToSend = eventsToSend[i];
var sentEvent = sentEvents[i];
var receivedEvent = receivedEvents[i];
MidiAsserts.AreEventsEqual(sentEvent.Event, eventToSend.Event, false, $"Sent event ({sentEvent.Event}) doesn't match the one that should be sent ({eventToSend.Event}).");
MidiAsserts.AreEventsEqual(sentEvent.Event, receivedEvent.Event, false, $"Received event ({receivedEvent.Event}) doesn't match the sent one ({sentEvent.Event}).");
var delay = (receivedEvent.Time - sentEvent.Time).Duration();
Assert.LessOrEqual(
delay,
maximumEventSendReceiveDelay,
$"Event was received too late (at {receivedEvent.Time} instead of {sentEvent.Time}). Delay is too big.");
}
}
