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.");
}
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++;
}
}
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 ResizeByRatio_EmptyFile()
{
var midiFile = new MidiFile();
midiFile.Resize(2.0);
MidiAsserts.AreEqual(midiFile.GetTimedEvents(), Enumerable.Empty <TimedEvent>(), false, 0, "Events are invalid.");
}
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 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 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.");
}
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 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++;
}
}
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.");
}
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 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 ChordsByNotes_EmptyCollection()
{
var notes = Enumerable.Empty <Note>();
var chords = notes.GetChords();
MidiAsserts.AreEqual(Enumerable.Empty <Chord>(), chords, "Chords are invalid.");
}
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.");
}
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 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.AreEqual(midiFile, convertedFile, true, $"Conversion of '{filePath}' is invalid.");
}
}
finally
{
Directory.Delete(outputDirectory, true);
}
}
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.");
}
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;
}
}
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.");
}
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");
}
public void CheckValidFilesAreEqualToSelf()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile1 = MidiFile.Read(filePath);
var midiFile2 = MidiFile.Read(filePath);
MidiAsserts.AreEqual(midiFile1, midiFile2, true, $"File '{filePath}' isn't equal to self.");
}
}
public void Clone()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile = MidiFile.Read(filePath);
var clonedMidiFile = midiFile.Clone();
MidiAsserts.AreEqual(clonedMidiFile, midiFile, true, $"Clone of the '{filePath}' doesn't equal to the original file.");
}
}
public void Split_TimeInsideNote()
{
var note = new Note((SevenBitNumber)100, 200, 100);
var time = 120;
var parts = note.Split(time);
MidiAsserts.AreEqual(new Note((SevenBitNumber)100, 20, 100), parts.LeftPart, "Left part is invalid.");
MidiAsserts.AreEqual(new Note((SevenBitNumber)100, 180, 120), parts.RightPart, "Right part is invalid.");
}
public void ConvertCsvToMidiFile_SingleTrackChunk_MetricTimes(MidiFileCsvLayout layout, bool orderEvents, string[] csvLines)
{
if (!orderEvents)
{
var tmp = csvLines[2];
csvLines[2] = csvLines[5];
csvLines[5] = tmp;
}
var midiFile = ConvertCsvToMidiFile(layout, TimeSpanType.Metric, csvLines);
TempoMap expectedTempoMap;
using (var tempoMapManager = new TempoMapManager(new TicksPerQuarterNoteTimeDivision(500)))
{
tempoMapManager.SetTempo(new MetricTimeSpan(0, 1, 3), new Tempo(300000));
expectedTempoMap = tempoMapManager.TempoMap;
}
var expectedEvents = new[]
{
new TimeAndMidiEvent(new MetricTimeSpan(),
new NoteOnEvent((SevenBitNumber)50, (SevenBitNumber)120)
{
Channel = (FourBitNumber)10
}),
new TimeAndMidiEvent(new MetricTimeSpan(),
new TextEvent("Test")),
new TimeAndMidiEvent(new MetricTimeSpan(0, 1, 0),
new NoteOnEvent((SevenBitNumber)50, (SevenBitNumber)110)
{
Channel = (FourBitNumber)7
}),
new TimeAndMidiEvent(new MetricTimeSpan(0, 1, 3),
new SetTempoEvent(300000)),
new TimeAndMidiEvent(new MetricTimeSpan(0, 1, 10),
new NoteOffEvent((SevenBitNumber)50, (SevenBitNumber)70)
{
Channel = (FourBitNumber)10
}),
new TimeAndMidiEvent(new MetricTimeSpan(0, 10, 3),
new NoteOffEvent((SevenBitNumber)50, (SevenBitNumber)80)
{
Channel = (FourBitNumber)7
})
}
.Select(te => new TimedEvent(te.Event, TimeConverter.ConvertFrom(te.Time, expectedTempoMap)))
.ToArray();
Assert.AreEqual(1, midiFile.GetTrackChunks().Count(), "Track chunks count is invalid.");
CollectionAssert.AreEqual(midiFile.GetTempoMap().GetTempoChanges(), expectedTempoMap.GetTempoChanges(), "Invalid tempo map.");
Assert.AreEqual(new TicksPerQuarterNoteTimeDivision(500), midiFile.TimeDivision, "Invalid time division.");
MidiAsserts.AreEqual(expectedEvents, midiFile.GetTimedEvents(), false, 0, "Invalid events.");
}
public void Clone()
{
var note = new Note((SevenBitNumber)100, 500, 123)
{
Channel = (FourBitNumber)10,
Velocity = (SevenBitNumber)45,
OffVelocity = (SevenBitNumber)54
};
MidiAsserts.AreEqual(note, note.Clone(), "Clone of a note doesn't equal to the original one.");
}
public void ChordsByNotes_MultipleChannels()
{
var notes = new[]
{
new Note((SevenBitNumber)1, 100, 0)
{
Channel = (FourBitNumber)10
},
new Note((SevenBitNumber)2, 100, 0)
{
Channel = (FourBitNumber)10
},
new Note((SevenBitNumber)3, 100, 100)
{
Channel = (FourBitNumber)10
},
new Note((SevenBitNumber)4, 100, 100)
{
Channel = (FourBitNumber)10
},
new Note((SevenBitNumber)5, 100, 1000),
new Note((SevenBitNumber)6, 100, 1000)
};
var chords = notes.GetChords();
MidiAsserts.AreEqual(
new[]
{
new Chord(
new Note((SevenBitNumber)1, 100, 0)
{
Channel = (FourBitNumber)10
},
new Note((SevenBitNumber)2, 100, 0)
{
Channel = (FourBitNumber)10
}),
new Chord(
new Note((SevenBitNumber)3, 100, 100)
{
Channel = (FourBitNumber)10
},
new Note((SevenBitNumber)4, 100, 100)
{
Channel = (FourBitNumber)10
}),
new Chord(
new Note((SevenBitNumber)5, 100, 1000),
new Note((SevenBitNumber)6, 100, 1000))
},
chords,
"Chords are invalid.");
}
private void GetObjects(
IEnumerable <ITimedObject> inputObjects,
IEnumerable <ITimedObject> outputObjects,
ObjectType objectType,
ObjectDetectionSettings settings)
{
var actualObjects = inputObjects
.GetObjects(objectType, settings)
.ToList();
MidiAsserts.AreEqual(outputObjects, actualObjects, true, 0, "Objects are invalid.");
}
private static void CompareTimedEvents(
IEnumerable <TimedEvent> actualTimedEvents,
IEnumerable <TimedEvent> expectedTimedEvents,
string message)
{
MidiAsserts.AreEqual(
actualTimedEvents,
expectedTimedEvents,
false,
0,
message);
}
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))
};
MidiAsserts.AreEqual(expectedEvents, timedEvents, false, 10, "Timed events saved incorrectly.");
}
}
}
}
