private void SplitByChannel_WithSettings(
ICollection <TimedEvent> timedEvents,
ICollection <ICollection <TimedEvent> > expectedTimedEvents,
bool copyNonChannelEventsToEachFile,
Predicate <TimedEvent> filter)
{
var midiFile = timedEvents.ToFile();
var midiFilesByChannel = midiFile
.SplitByChannel(new SplitFileByChannelSettings
{
CopyNonChannelEventsToEachFile = copyNonChannelEventsToEachFile,
Filter = filter
})
.ToList();
Assert.AreEqual(expectedTimedEvents.Count, midiFilesByChannel.Count, "Invalid count of new files.");
var expectedTimedEventsEnumerator = expectedTimedEvents.GetEnumerator();
var newMidiFilesEnumerator = midiFilesByChannel.GetEnumerator();
var i = 0;
while (expectedTimedEventsEnumerator.MoveNext() && newMidiFilesEnumerator.MoveNext())
{
var expectedEvents = expectedTimedEventsEnumerator.Current;
var actualEvents = newMidiFilesEnumerator.Current.GetTimedEvents();
MidiAsserts.AreEqual(expectedEvents, actualEvents, $"Invalid events of file {i}.");
i++;
}
}
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 void SplitByChannel(
ICollection <TimedEvent> timedEvents,
ICollection <ICollection <TimedEvent> > expectedTimedEvents,
TimeDivision timeDivision = null)
{
var midiFile = timedEvents.ToFile();
if (timeDivision != null)
{
midiFile.TimeDivision = timeDivision;
}
var midiFilesByChannel = midiFile.SplitByChannel().ToList();
Assert.AreEqual(expectedTimedEvents.Count, midiFilesByChannel.Count, "Invalid count of new files.");
var expectedTimedEventsEnumerator = expectedTimedEvents.GetEnumerator();
var newMidiFilesEnumerator = midiFilesByChannel.GetEnumerator();
var i = 0;
while (expectedTimedEventsEnumerator.MoveNext() && newMidiFilesEnumerator.MoveNext())
{
var expectedEvents = expectedTimedEventsEnumerator.Current;
var actualEvents = newMidiFilesEnumerator.Current.GetTimedEvents();
MidiAsserts.AreEqual(expectedEvents, actualEvents, $"Invalid events of file {i}.");
Assert.AreEqual(midiFile.TimeDivision, newMidiFilesEnumerator.Current.TimeDivision, $"Invalid time division of file {i}.");
i++;
}
}
private void RemoveTimedEvents_TrackChunks_WithoutPredicate(
bool wrapToFile,
ICollection <ICollection <MidiEvent> > midiEvents)
{
var trackChunks = midiEvents.Select(e => new TrackChunk(e)).ToList();
if (wrapToFile)
{
var midiFile = new MidiFile(trackChunks);
Assert.AreEqual(
midiEvents.Sum(e => e.Count),
midiFile.RemoveTimedEvents(),
"Invalid count of removed timed events.");
MidiAsserts.AreEqual(new MidiFile(midiEvents.Select(e => new TrackChunk())), midiFile, false, "Events are invalid.");
Assert.IsTrue(
midiFile.GetTrackChunks().SelectMany(c => c.Events).All(e => midiEvents.SelectMany(ee => ee).Any(ee => object.ReferenceEquals(e, ee))),
"There are new events references.");
}
else
{
Assert.AreEqual(
midiEvents.Sum(e => e.Count),
trackChunks.RemoveTimedEvents(),
"Invalid count of removed timed events.");
MidiAsserts.AreEqual(midiEvents.Select(e => new TrackChunk()), trackChunks, true, "Events are invalid.");
Assert.IsTrue(
trackChunks.SelectMany(c => c.Events).All(e => midiEvents.SelectMany(ee => ee).Any(ee => object.ReferenceEquals(e, ee))),
"There are new events references.");
}
}
public void ConvertCsvToMidiFile_SingleTrackChunk(MidiFileCsvLayout layout, bool orderEvents, string[] csvLines)
{
if (!orderEvents)
{
var tmp = csvLines[2];
csvLines[2] = csvLines[4];
csvLines[4] = tmp;
}
var midiFile = ConvertCsvToMidiFile(layout, TimeSpanType.Midi, csvLines);
var expectedEvents = new[]
{
new TimedEvent(new NoteOnEvent((SevenBitNumber)50, (SevenBitNumber)120)
{
Channel = (FourBitNumber)10
}, 0),
new TimedEvent(new TextEvent("Test"), 0),
new TimedEvent(new NoteOnEvent((SevenBitNumber)50, (SevenBitNumber)110)
{
Channel = (FourBitNumber)7
}, 100),
new TimedEvent(new NoteOffEvent((SevenBitNumber)50, (SevenBitNumber)70)
{
Channel = (FourBitNumber)10
}, 250),
new TimedEvent(new NoteOffEvent((SevenBitNumber)50, (SevenBitNumber)80)
{
Channel = (FourBitNumber)7
}, 1000)
};
Assert.AreEqual(1, midiFile.GetTrackChunks().Count(), "Track chunks count is invalid.");
MidiAsserts.AreEqual(expectedEvents, midiFile.GetTimedEvents(), false, 0, "Invalid events.");
}
public void ConvertCsvToMidiFile_NoteNumberFormat(NoteNumberFormat noteNumberFormat, string[] csvLines)
{
var midiFile = ConvertCsvToMidiFile(MidiFileCsvLayout.DryWetMidi, TimeSpanType.Midi, csvLines, NoteFormat.Note, noteNumberFormat);
var expectedObjects = new ITimedObject[]
{
new Note((SevenBitNumber)50, 250, 0)
{
Channel = (FourBitNumber)10,
Velocity = (SevenBitNumber)120,
OffVelocity = (SevenBitNumber)70
},
new TimedEvent(new TextEvent("Test"), 0),
new Note((SevenBitNumber)50, 900, 100)
{
Channel = (FourBitNumber)7,
Velocity = (SevenBitNumber)110,
OffVelocity = (SevenBitNumber)80
}
};
Assert.AreEqual(1, midiFile.GetTrackChunks().Count(), "Track chunks count is invalid.");
MidiAsserts.AreEqual(
expectedObjects,
midiFile.GetObjects(ObjectType.TimedEvent | ObjectType.Note),
false,
0,
"Invalid objects.");
}
public void ResizeByRatio_Midi()
{
var timedEvents = new[]
{
new TimedEvent(new SetTempoEvent(200000), 0),
new TimedEvent(new TextEvent("Text"), 100),
new TimedEvent(new TextEvent("Text 2"), 150),
new TimedEvent(new NoteOnEvent((SevenBitNumber)10, (SevenBitNumber)100), 50),
new TimedEvent(new NoteOffEvent((SevenBitNumber)10, (SevenBitNumber)50), 80)
};
var midiFile = timedEvents.ToFile();
midiFile.Resize(2.0);
MidiAsserts.AreEqual(
midiFile.GetTimedEvents(),
new[]
{
new TimedEvent(new SetTempoEvent(200000), 0),
new TimedEvent(new NoteOnEvent((SevenBitNumber)10, (SevenBitNumber)100), 100),
new TimedEvent(new NoteOffEvent((SevenBitNumber)10, (SevenBitNumber)50), 160),
new TimedEvent(new TextEvent("Text"), 200),
new TimedEvent(new TextEvent("Text 2"), 300),
},
false,
0,
"Events are invalid.");
}
private void SplitByChunks_WithSettings(
ICollection <MidiChunk> chunks,
ICollection <MidiChunk> expectedChunks,
SplitFileByChunksSettings settings,
TimeDivision timeDivision = null)
{
var midiFile = new MidiFile(chunks);
if (timeDivision != null)
{
midiFile.TimeDivision = timeDivision;
}
var midiFilesByChunks = midiFile.SplitByChunks(settings).ToList();
Assert.AreEqual(expectedChunks.Count, midiFilesByChunks.Count, "Invalid count of new files.");
var i = 0;
foreach (var chunk in expectedChunks)
{
MidiAsserts.AreEqual(
new MidiFile(chunk)
{
TimeDivision = midiFile.TimeDivision
},
midiFilesByChunks[i],
false,
$"File {i} is invalid.");
i++;
}
}
public void ResizeByRatio_EmptyFile()
{
var midiFile = new MidiFile();
midiFile.Resize(2.0);
MidiAsserts.AreEqual(midiFile.GetTimedEvents(), Enumerable.Empty <TimedEvent>(), false, 0, "Events are invalid.");
}
public void Resize_EmptyFile()
{
var midiFile = new MidiFile();
midiFile.Resize(new MetricTimeSpan(1, 0, 0));
MidiAsserts.AreEqual(midiFile.GetTimedEvents(), Enumerable.Empty <TimedEvent>(), false, 0, "Events are invalid.");
}
private void ProcessChords_DetectionSettings_EventsCollection_WithoutPredicate(
ContainerType containerType,
ChordDetectionSettings settings,
ICollection <MidiEvent> midiEvents,
Action <Chord> action,
ICollection <MidiEvent> expectedMidiEvents)
{
var chordsCount = midiEvents.GetChords(settings).Count;
switch (containerType)
{
case ContainerType.EventsCollection:
{
var eventsCollection = new EventsCollection();
eventsCollection.AddRange(midiEvents);
Assert.AreEqual(
chordsCount,
eventsCollection.ProcessChords(action, settings),
"Invalid count of processed chords.");
var expectedEventsCollection = new EventsCollection();
expectedEventsCollection.AddRange(expectedMidiEvents);
MidiAsserts.AreEqual(expectedEventsCollection, eventsCollection, true, "Events are invalid.");
Assert.IsTrue(
eventsCollection.All(e => midiEvents.Any(ee => object.ReferenceEquals(e, ee))),
"There are new events references.");
}
break;
case ContainerType.TrackChunk:
{
var trackChunk = new TrackChunk(midiEvents);
Assert.AreEqual(
chordsCount,
trackChunk.ProcessChords(action, settings),
"Invalid count of processed chords.");
var expectedTrackChunk = new TrackChunk(expectedMidiEvents);
MidiAsserts.AreEqual(expectedTrackChunk, trackChunk, true, "Events are invalid.");
Assert.IsTrue(
trackChunk.Events.All(e => midiEvents.Any(ee => object.ReferenceEquals(e, ee))),
"There are new events references.");
}
break;
case ContainerType.TrackChunks:
case ContainerType.File:
{
ProcessChords_DetectionSettings_TrackChunks_WithoutPredicate(
containerType == ContainerType.File,
settings,
new[] { midiEvents },
action,
new[] { expectedMidiEvents });
}
break;
}
}
private static void ConvertCsvToNotes(
IEnumerable <NoteWithCustomTimeAndLength> expectedNotes,
TempoMap tempoMap,
TimeSpanType timeType,
string[] csvLines,
NoteNumberFormat noteNumberFormat = NoteNumberFormat.NoteNumber,
TimeSpanType noteLengthType = TimeSpanType.Midi,
char delimiter = ',')
{
var filePath = Path.GetTempFileName();
FileOperations.WriteAllLinesToFile(filePath, csvLines);
var settings = new NoteCsvConversionSettings
{
TimeType = timeType,
NoteNumberFormat = noteNumberFormat,
NoteLengthType = noteLengthType
};
settings.CsvSettings.CsvDelimiter = delimiter;
try
{
var actualNotes = new CsvConverter().ConvertCsvToNotes(filePath, tempoMap, settings).ToList();
MidiAsserts.AreEqual(expectedNotes.Select(n => n.GetNote(tempoMap)), actualNotes, "Notes are invalid.");
ConvertNotesToFromCsv(actualNotes, tempoMap, filePath, settings);
}
finally
{
FileOperations.DeleteFile(filePath);
}
}
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 Read_UseFixedSizeBuffer(int bufferSize)
{
var noBufferingSettings = new ReadingSettings
{
ReaderSettings = new ReaderSettings
{
BufferingPolicy = BufferingPolicy.DontUseBuffering
}
};
var fixedSizeBufferingSettings = new ReadingSettings
{
ReaderSettings = new ReaderSettings
{
BufferingPolicy = BufferingPolicy.UseFixedSizeBuffer,
BufferSize = bufferSize
}
};
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var expectedMidiFile = MidiFile.Read(filePath, noBufferingSettings);
var midiFile = MidiFile.Read(filePath, fixedSizeBufferingSettings);
MidiAsserts.AreFilesEqual(expectedMidiFile, midiFile, true, $"File '{filePath}' is invalid.");
}
}
private static void ConvertMidiFileToFromCsv(MidiFileCsvConversionSettings settings)
{
var tempPath = Path.GetTempPath();
var outputDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
Directory.CreateDirectory(outputDirectory);
try
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile = MidiFile.Read(filePath);
var outputFilePath = Path.Combine(outputDirectory, Path.GetFileName(Path.ChangeExtension(filePath, "csv")));
var csvConverter = new CsvConverter();
csvConverter.ConvertMidiFileToCsv(midiFile, outputFilePath, true, settings);
var convertedFile = csvConverter.ConvertCsvToMidiFile(outputFilePath, settings);
MidiAsserts.AreFilesEqual(midiFile, convertedFile, true, $"Conversion of '{filePath}' is invalid.");
}
}
finally
{
Directory.Delete(outputDirectory, true);
}
}
public static void TestTimedEventsWithExactOrder(
Pattern pattern,
ICollection <TimedEventInfo> expectedTimedEventsInfos,
params Tuple <long, Tempo>[] tempoChanges)
{
TempoMap tempoMap;
using (var tempoMapManager = new TempoMapManager())
{
foreach (var tempoChange in tempoChanges)
{
tempoMapManager.SetTempo(tempoChange.Item1, tempoChange.Item2);
}
tempoMap = tempoMapManager.TempoMap;
}
var midiFile = pattern.ToFile(tempoMap, Channel);
var expectedTimedEvents = expectedTimedEventsInfos.Select(i =>
new TimedEvent(i.Event, TimeConverter.ConvertFrom(i.Time ?? new MidiTimeSpan(), tempoMap)));
var actualTimedEvents = midiFile.GetTimedEvents();
MidiAsserts.AreEqual(expectedTimedEvents, actualTimedEvents, false, 0, "Events have invalid order.");
}
public void CheckChordChannel()
{
var initialChannel = (FourBitNumber)0;
var chord = new Chord(new Note((SevenBitNumber)70), new Note((SevenBitNumber)80));
Assert.AreEqual(initialChannel, chord.Channel, "Invalid channel after chord created.");
foreach (var note in chord.Notes)
{
Assert.AreEqual(initialChannel, ((NoteOnEvent)note.TimedNoteOnEvent.Event).Channel, "Invalid channel of Note On timed event after chord created.");
Assert.AreEqual(initialChannel, ((NoteOffEvent)note.TimedNoteOffEvent.Event).Channel, "Invalid channel of Note Off timed event after chord created.");
MidiAsserts.AreEqual(note.TimedNoteOnEvent, note.GetTimedNoteOnEvent(), "Invalid Note On timed event after chord created.");
MidiAsserts.AreEqual(note.TimedNoteOffEvent, note.GetTimedNoteOffEvent(), "Invalid Note Off timed event after chord created.");
}
var newChannel = (FourBitNumber)6;
chord.Channel = newChannel;
Assert.AreEqual(newChannel, chord.Channel, "Invalid channel after update.");
foreach (var note in chord.Notes)
{
Assert.AreEqual(newChannel, ((NoteOnEvent)note.TimedNoteOnEvent.Event).Channel, "Invalid channel of Note On timed event after update.");
Assert.AreEqual(newChannel, ((NoteOffEvent)note.TimedNoteOffEvent.Event).Channel, "Invalid channel of Note Off timed event after update.");
MidiAsserts.AreEqual(note.TimedNoteOnEvent, note.GetTimedNoteOnEvent(), "Invalid Note On timed event after update.");
MidiAsserts.AreEqual(note.TimedNoteOffEvent, note.GetTimedNoteOffEvent(), "Invalid Note Off timed event after update.");
}
}
public void CheckChordOffVelocity()
{
var initialOffVelocity = SevenBitNumber.MinValue;
var chord = new Chord(new Note((SevenBitNumber)70), new Note((SevenBitNumber)80));
Assert.AreEqual(initialOffVelocity, chord.OffVelocity, "Invalid off velocity after chord created.");
foreach (var note in chord.Notes)
{
Assert.AreEqual(Note.DefaultVelocity, ((NoteOnEvent)note.TimedNoteOnEvent.Event).Velocity, "Invalid off velocity of Note On timed event after chord created.");
Assert.AreEqual(initialOffVelocity, ((NoteOffEvent)note.TimedNoteOffEvent.Event).Velocity, "Invalid off velocity of Note Off timed event after chord created.");
MidiAsserts.AreEqual(note.TimedNoteOnEvent, note.GetTimedNoteOnEvent(), "Invalid Note On timed event after chord created.");
MidiAsserts.AreEqual(note.TimedNoteOffEvent, note.GetTimedNoteOffEvent(), "Invalid Note Off timed event after chord created.");
}
var newOffVelocity = (SevenBitNumber)60;
chord.OffVelocity = newOffVelocity;
Assert.AreEqual(newOffVelocity, chord.OffVelocity, "Invalid off velocity after update.");
foreach (var note in chord.Notes)
{
Assert.AreEqual(Note.DefaultVelocity, ((NoteOnEvent)note.TimedNoteOnEvent.Event).Velocity, "Invalid off velocity of Note On timed event after update.");
Assert.AreEqual(newOffVelocity, ((NoteOffEvent)note.TimedNoteOffEvent.Event).Velocity, "Invalid off velocity of Note Off timed event after update.");
MidiAsserts.AreEqual(note.TimedNoteOnEvent, note.GetTimedNoteOnEvent(), "Invalid Note On timed event after update.");
MidiAsserts.AreEqual(note.TimedNoteOffEvent, note.GetTimedNoteOffEvent(), "Invalid Note Off timed event after update.");
}
}
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 SplitByStep_UnequalDivision()
{
var tempoMap = TempoMap.Default;
var partsNumber = 10;
var step = 1000L;
var inputObjects = CreateInputObjects(step * (partsNumber - 1) + step / 2).ToArray();
var expectedObjects = inputObjects.SelectMany(o => Split(o, Enumerable.Range(1, partsNumber - 1).Select(i => o.Time + step * i)));
var actualObjects = Splitter.SplitByStep(inputObjects, (MidiTimeSpan)step, tempoMap).ToArray();
Assert.AreEqual(inputObjects.Length * partsNumber,
actualObjects.Length,
"Parts count is invalid.");
Assert.IsTrue(Enumerable.Range(0, inputObjects.Length)
.SelectMany(i => actualObjects.Skip(partsNumber * i)
.Take(partsNumber - 1))
.All(o => o.Length == step),
"Length of some objects (except the last one) doesn't equal to the step.");
Assert.IsTrue(Enumerable.Range(0, inputObjects.Length)
.All(i => actualObjects.Skip(partsNumber * i)
.Take(partsNumber)
.Last()
.Length < step),
"Last object's length is not less than the step.");
MidiAsserts.AreEqual(
expectedObjects.OfType <ITimedObject>(),
actualObjects.OfType <ITimedObject>(),
true,
0,
"Objects are 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 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 ChordsByNotes_EmptyCollection()
{
var notes = Enumerable.Empty <Note>();
var chords = notes.GetChords();
MidiAsserts.AreEqual(Enumerable.Empty <Chord>(), chords, "Chords are invalid.");
}
public void CheckNoteNameAndOctave()
{
var initialNoteName = DryWetMidi.MusicTheory.NoteName.A;
var initialOctave = 4;
var note = new Note(initialNoteName, initialOctave);
Assert.AreEqual(initialNoteName, note.NoteName, "Invalid note name after note created.");
Assert.AreEqual(initialOctave, note.Octave, "Invalid octave after note created.");
Assert.AreEqual(initialNoteName, ((NoteOnEvent)note.TimedNoteOnEvent.Event).GetNoteName(), "Invalid note name of Note On timed event after note created.");
Assert.AreEqual(initialOctave, ((NoteOnEvent)note.TimedNoteOnEvent.Event).GetNoteOctave(), "Invalid octave of Note On timed event after note created.");
Assert.AreEqual(initialNoteName, ((NoteOffEvent)note.TimedNoteOffEvent.Event).GetNoteName(), "Invalid note name of Note Off timed event after note created.");
Assert.AreEqual(initialOctave, ((NoteOffEvent)note.TimedNoteOffEvent.Event).GetNoteOctave(), "Invalid octave of Note Off timed event after note created.");
MidiAsserts.AreEqual(note.TimedNoteOnEvent, note.GetTimedNoteOnEvent(), "Invalid Note On timed event after note created.");
MidiAsserts.AreEqual(note.TimedNoteOffEvent, note.GetTimedNoteOffEvent(), "Invalid Note Off timed event after note created.");
var newNoteName = DryWetMidi.MusicTheory.NoteName.B;
var newOctave = 3;
note.SetNoteNameAndOctave(newNoteName, newOctave);
Assert.AreEqual(newNoteName, note.NoteName, "Invalid note name after update.");
Assert.AreEqual(newOctave, note.Octave, "Invalid octave after update.");
Assert.AreEqual(newNoteName, ((NoteOnEvent)note.TimedNoteOnEvent.Event).GetNoteName(), "Invalid note name of Note On timed event after update.");
Assert.AreEqual(newOctave, ((NoteOnEvent)note.TimedNoteOnEvent.Event).GetNoteOctave(), "Invalid octave of Note On timed event after update.");
Assert.AreEqual(newNoteName, ((NoteOffEvent)note.TimedNoteOffEvent.Event).GetNoteName(), "Invalid note name of Note Off timed event after update.");
Assert.AreEqual(newOctave, ((NoteOffEvent)note.TimedNoteOffEvent.Event).GetNoteOctave(), "Invalid octave of Note Off timed event after update.");
MidiAsserts.AreEqual(note.TimedNoteOnEvent, note.GetTimedNoteOnEvent(), "Invalid Note On timed event after update.");
MidiAsserts.AreEqual(note.TimedNoteOffEvent, note.GetTimedNoteOffEvent(), "Invalid Note Off timed event after update.");
}
private void RemoveTimedEvents_EventsCollection_WithPredicate(
ContainerType containerType,
ICollection <MidiEvent> midiEvents,
Predicate <TimedEvent> match,
ICollection <MidiEvent> expectedMidiEvents,
int expectedRemovedCount)
{
var eventsCollection = new EventsCollection();
eventsCollection.AddRange(midiEvents);
switch (containerType)
{
case ContainerType.EventsCollection:
{
Assert.AreEqual(
expectedRemovedCount,
eventsCollection.RemoveTimedEvents(match),
"Invalid count of removed timed events.");
var expectedEventsCollection = new EventsCollection();
expectedEventsCollection.AddRange(expectedMidiEvents);
MidiAsserts.AreEqual(expectedEventsCollection, eventsCollection, true, "Events are invalid.");
Assert.IsTrue(
eventsCollection.All(e => midiEvents.Any(ee => object.ReferenceEquals(e, ee))),
"There are new events references.");
}
break;
case ContainerType.TrackChunk:
{
var trackChunk = new TrackChunk(eventsCollection);
Assert.AreEqual(
expectedRemovedCount,
trackChunk.RemoveTimedEvents(match),
"Invalid count of removed timed events.");
var expectedTrackChunk = new TrackChunk(expectedMidiEvents);
MidiAsserts.AreEqual(expectedTrackChunk, trackChunk, true, "Events are invalid.");
Assert.IsTrue(
trackChunk.Events.All(e => midiEvents.Any(ee => object.ReferenceEquals(e, ee))),
"There are new events references.");
}
break;
case ContainerType.TrackChunks:
case ContainerType.File:
{
RemoveTimedEvents_TrackChunks_WithPredicate(
containerType == ContainerType.File,
new[] { midiEvents },
match,
new[] { expectedMidiEvents },
expectedRemovedCount);
}
break;
}
}
private static void CompareEvents(MidiEvent expectedMidiEvent, MidiEvent actualMidiEvent)
{
MidiAsserts.AreEventsEqual(
expectedMidiEvent,
actualMidiEvent,
false,
"MIDI event read incorrectly.");
}
public void GetTimedEventsAndNotes_EmptyCollections()
{
var timedEvents = Enumerable.Empty <TimedEvent>();
var actualObjects = timedEvents.GetTimedEventsAndNotes().ToList();
var expectedObjects = Enumerable.Empty <TimedEvent>();
MidiAsserts.AreEqual(expectedObjects, actualObjects, true, 0, "Objects are invalid.");
}
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 CheckValidFilesAreEqualToSelf()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile1 = MidiFile.Read(filePath);
var midiFile2 = MidiFile.Read(filePath);
MidiAsserts.AreFilesEqual(midiFile1, midiFile2, true, $"File '{filePath}' isn't equal to self.");
}
}
private static void TestGetNotesAndRests(
IEnumerable <Note> inputNotes,
RestSeparationPolicy restSeparationPolicy,
IEnumerable <ILengthedObject> expectedObjects)
{
var actualObjects = inputNotes.GetNotesAndRests(restSeparationPolicy);
MidiAsserts.AreEqual(expectedObjects, actualObjects, true, 0, "Objects are invalid");
}
