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 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.");
}
}
public void ReadFileWithoutReadingHandlers()
{
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events());
var tempoMap = midiFile.GetTempoMap();
var notes = midiFile.GetNotes();
var timedEvents = midiFile.GetTimedEvents();
}
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);
}
}
public void Read_WithEmptyHandler()
{
var handler = new EmptyHandler();
var settings = new ReadingSettings();
settings.ReadingHandlers.Add(handler);
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events(), settings);
}
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.");
}
}
public void Clone()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile = MidiFile.Read(filePath);
var clonedMidiFile = midiFile.Clone();
MidiAsserts.AreFilesEqual(clonedMidiFile, midiFile, true, $"Clone of the '{filePath}' doesn't equal to the original file.");
}
}
private void ReadFileWithNotesReadingHandler(bool sortNotes)
{
var handler = new NotesReadingHandler(sortNotes);
var settings = new ReadingSettings();
settings.ReadingHandlers.Add(handler);
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events(), settings);
var notes = handler.Notes;
}
public void ReadFileWithTempoMapReadingHandler()
{
var handler = new TempoMapReadingHandler();
var settings = new ReadingSettings();
settings.ReadingHandlers.Add(handler);
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events(), settings);
var tempoMap = handler.TempoMap;
}
private void ReadFileWithTimedEventsReadingHandler(bool sortEvents)
{
var handler = new TimedEventsReadingHandler(sortEvents);
var settings = new ReadingSettings();
settings.ReadingHandlers.Add(handler);
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events(), settings);
var timedEvents = handler.TimedEvents;
}
public void Clone_Read()
{
foreach (var filePath in TestFilesProvider.GetValidFiles())
{
var midiFile = MidiFile.Read(filePath);
var clonedMidiFile = midiFile.Clone();
Assert.IsTrue(MidiFileEquality.AreEqual(clonedMidiFile, midiFile, true),
$"Clone of the '{filePath}' doesn't equal to the original file.");
}
}
public void Read_ExtraTrackChunk_Skip()
{
foreach (var filePath in TestFilesProvider.GetInvalidFilesPaths(DirectoriesNames.ExtraTrackChunk))
{
var midiFile = MidiFile.Read(filePath, new ReadingSettings
{
ExtraTrackChunkPolicy = ExtraTrackChunkPolicy.Skip
});
CollectionAssert.IsEmpty(midiFile.GetTrackChunks(), "Track chunks count is invalid.");
}
}
public void Read_ExtraTrackChunk_Read()
{
foreach (var filePath in TestFilesProvider.GetInvalidFilesPaths(DirectoriesNames.ExtraTrackChunk))
{
var midiFile = MidiFile.Read(filePath, new ReadingSettings
{
ExtraTrackChunkPolicy = ExtraTrackChunkPolicy.Read
});
Assert.AreEqual(1, midiFile.GetTrackChunks().Count(), "Track chunks count is invalid.");
}
}
public void SplitByChannel_ValidFiles()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile = MidiFile.Read(filePath);
var originalChannels = midiFile
.GetTrackChunks()
.SelectMany(c => c.Events)
.OfType <ChannelEvent>()
.Select(e => e.Channel)
.Distinct()
.ToArray();
if (!originalChannels.Any())
{
continue;
}
var filesByChannel = midiFile.SplitByChannel().ToList();
var allChannels = new List <FourBitNumber>(FourBitNumber.Values.Length);
foreach (var fileByChannel in filesByChannel)
{
Assert.AreEqual(
fileByChannel.TimeDivision,
midiFile.TimeDivision,
"Time division of new file doesn't equal to the time division of the original one.");
var channels = fileByChannel
.GetTrackChunks()
.SelectMany(c => c.Events)
.OfType <ChannelEvent>()
.Select(e => e.Channel)
.Distinct()
.ToArray();
Assert.AreEqual(
1,
channels.Length,
"New file contains channel events for different channels.");
allChannels.Add(channels.First());
}
allChannels.Sort();
CollectionAssert.AreEqual(
originalChannels.OrderBy(c => c),
allChannels,
"Channels from new files differs from those from original one.");
}
}
public void CheckValidFilesReadingByReferences()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var referenceMidiFile = TestFilesProvider.GetValidFileReference(filePath, out var noFile);
if (noFile)
{
continue;
}
var midiFile = MidiFile.Read(filePath);
MidiAsserts.AreFilesEqual(midiFile, referenceMidiFile, false, $"File '{filePath}' read wrong.");
}
}
public void ShiftEvents_ValidFiles_Midi()
{
var distance = 10000;
foreach (var midiFile in TestFilesProvider.GetValidFiles())
{
var originalTimes = midiFile.GetTimedEvents().Select(e => e.Time).ToList();
midiFile.ShiftEvents((MidiTimeSpan)distance);
var newTimes = midiFile.GetTimedEvents().Select(e => e.Time).ToList();
Assert.IsTrue(midiFile.GetTimedEvents().All(e => e.Time >= distance), "Some events are not shifted.");
CollectionAssert.AreEqual(originalTimes, newTimes.Select(t => t - distance));
}
}
public void ShiftEvents_ValidFiles_Metric()
{
var distance = new MetricTimeSpan(0, 1, 0);
foreach (var midiFile in TestFilesProvider.GetValidFiles())
{
midiFile.ShiftEvents(distance);
var tempoMap = midiFile.GetTempoMap();
Assert.IsTrue(midiFile.GetTimedEvents()
.Select(e => e.TimeAs <MetricTimeSpan>(tempoMap).CompareTo(distance))
.All(t => t >= 0),
"Some events are not shifted.");
}
}
public void Read_ReadFromMemory()
{
var settings = new ReadingSettings();
Assert.AreEqual(BufferingPolicy.UseFixedSizeBuffer, settings.ReaderSettings.BufferingPolicy, "Initial buffering policy is invalid.");
settings.ReaderSettings.ReadFromMemory = true;
Assert.AreEqual(BufferingPolicy.BufferAllData, settings.ReaderSettings.BufferingPolicy, "Buffering policy is invalid after ReadFromMemory set.");
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var expectedMidiFile = MidiFile.Read(filePath);
var midiFile = MidiFile.Read(filePath, settings);
MidiAsserts.AreFilesEqual(expectedMidiFile, midiFile, true, $"File '{filePath}' is invalid.");
}
}
public void SplitByNotes_ValidFiles()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var midiFile = MidiFile.Read(filePath);
var fileIndex = 0;
var allNoteEventsCount = 0;
var allNotesIds = new HashSet <NoteId>();
foreach (var fileByNotes in midiFile.SplitByNotes())
{
var noteEvents = fileByNotes.GetTrackChunks()
.SelectMany(c => c.Events)
.OfType <NoteEvent>()
.ToList();
var notesIds = new HashSet <NoteId>(noteEvents.Select(n => n.GetNoteId()));
allNoteEventsCount += noteEvents.Count;
foreach (var noteId in notesIds)
{
allNotesIds.Add(noteId);
}
Assert.AreEqual(1,
notesIds.Count,
$"New file ({fileIndex}) contains different notes.");
fileIndex++;
}
var originalNoteEvents = midiFile.GetTrackChunks()
.SelectMany(c => c.Events)
.OfType <NoteEvent>()
.ToList();
var originalNoteEventsCount = originalNoteEvents.Count();
var originalNotesIds = new HashSet <NoteId>(originalNoteEvents.Select(e => e.GetNoteId()));
Assert.AreEqual(originalNoteEventsCount,
allNoteEventsCount,
"Notes count of new files doesn't equal to count of notes of the original file.");
Assert.IsTrue(originalNotesIds.SetEquals(allNotesIds),
"Notes in new files differ from notes in the original file.");
}
}
private void ReadFileWithReadingHandlers(bool sortObjects)
{
var notesReadingHandler = new NotesReadingHandler(sortObjects);
var timedEventsReadingHandler = new TimedEventsReadingHandler(sortObjects);
var tempoMapReadingHandler = new TempoMapReadingHandler();
var settings = new ReadingSettings();
settings.ReadingHandlers.Add(notesReadingHandler);
settings.ReadingHandlers.Add(timedEventsReadingHandler);
settings.ReadingHandlers.Add(tempoMapReadingHandler);
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events(), settings);
var tempoMap = tempoMapReadingHandler.TempoMap;
var timedEvents = timedEventsReadingHandler.TimedEvents;
var notes = notesReadingHandler.Notes;
}
public void CheckValidFilesAreNotEqualToAnother()
{
var filesPaths = TestFilesProvider.GetValidFilesPaths().ToArray();
for (var i = 0; i < filesPaths.Length; i++)
{
var iFilePath = filesPaths[i];
var iMidiFile = MidiFile.Read(iFilePath);
for (var j = i + 1; j < filesPaths.Length; j++)
{
var jFilePath = filesPaths[j];
var jMidiFile = MidiFile.Read(jFilePath);
MidiAsserts.AreFilesNotEqual(iMidiFile, jMidiFile, true, $"File '{iFilePath}' equals to another one '{jFilePath}'.");
}
}
}
public void ReadWriteRead()
{
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
MidiFile midiFile = null;
MidiFile midiFile2 = null;
Assert.DoesNotThrow(() =>
{
midiFile = MidiFile.Read(filePath);
midiFile2 = MidiFileTestUtilities.Read(midiFile, null, null);
},
$"Read/Write/Read failed for '{filePath}'.");
Assert.IsNotNull(midiFile, "MIDI file is null.");
MidiAsserts.AreFilesEqual(midiFile, midiFile2, true, $"Reread failed for '{filePath}'.");
}
}
private void ReadFilesWithException <TException>(string directoryName, ReadingSettings readingSettings)
where TException : Exception
{
readingSettings.ReaderSettings.BufferingPolicy = BufferingPolicy.DontUseBuffering;
foreach (var filePath in TestFilesProvider.GetInvalidFilesPaths(directoryName))
{
MidiFile midiFile = null;
Assert.Throws <TException>(() => midiFile = MidiFile.Read(filePath, readingSettings), $"Exception not thrown for '{filePath}'.");
var fileBasePath = TestFilesProvider.GetFileBasePath(filePath);
var remoteFileAddress = TestFilesProvider.GetRemoteFileAddress(fileBasePath);
//
var nonSeekableStream = new NonSeekableStream(filePath);
MidiFile nonSeekableFile = null;
Assert.Throws <TException>(() => nonSeekableFile = MidiFile.Read(nonSeekableStream, readingSettings), $"Exception not thrown for file '{filePath}' read from non-seekable stream.");
MidiAsserts.AreFilesEqual(midiFile, nonSeekableFile, true, $"Non-seekable MIDI file '{fileBasePath}' is invalid.");
//
readingSettings.ReaderSettings.BufferingPolicy = BufferingPolicy.BufferAllData;
MidiFile inMemoryMidiFile = null;
Assert.Throws <TException>(() => inMemoryMidiFile = MidiFile.Read(filePath, readingSettings), $"Exception not thrown for '{filePath}' read with putting data in memory.");
MidiAsserts.AreFilesEqual(midiFile, inMemoryMidiFile, true, $"In-memory MIDI file '{fileBasePath}' is invalid.");
//
readingSettings.ReaderSettings.BufferingPolicy = BufferingPolicy.UseFixedSizeBuffer;
MidiFile fixedSizeBufferedMidiFile = null;
Assert.Throws <TException>(() => fixedSizeBufferedMidiFile = MidiFile.Read(filePath, readingSettings), $"Exception not thrown for '{filePath}' read with fixed size buffer.");
MidiAsserts.AreFilesEqual(midiFile, fixedSizeBufferedMidiFile, true, $"Fixed size buffered MIDI file '{fileBasePath}' is invalid.");
//
readingSettings.ReaderSettings.BufferingPolicy = BufferingPolicy.DontUseBuffering;
}
}
public void Read_BufferAllData()
{
var noBufferingSettings = new ReadingSettings
{
ReaderSettings = new ReaderSettings
{
BufferingPolicy = BufferingPolicy.DontUseBuffering
}
};
var bufferAllDataSettings = new ReadingSettings();
bufferAllDataSettings.ReaderSettings.BufferingPolicy = BufferingPolicy.BufferAllData;
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var expectedMidiFile = MidiFile.Read(filePath, noBufferingSettings);
var midiFile = MidiFile.Read(filePath, bufferAllDataSettings);
MidiAsserts.AreFilesEqual(expectedMidiFile, midiFile, true, $"File '{filePath}' is invalid.");
}
}
public void CheckFileEventsReceivingOnConnectedDevices()
{
var filesToTestCount = 5;
var maxFileDuration = TimeSpan.FromSeconds(10);
var filesToTest = TestFilesProvider.GetValidFiles(
f => f.GetTrackChunks().Count() == 1,
f => (TimeSpan)f.GetDuration <MetricTimeSpan>() < maxFileDuration)
.OrderByDescending(f => f.GetDuration <MetricTimeSpan>())
.Take(filesToTestCount)
.ToArray();
Debug.Assert(filesToTest.Length == filesToTestCount, "Not enough files for test.");
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;
if (eventToSend.Event is SysExEvent)
{
continue;
}
eventsToSend.Add(eventToSend);
}
CheckEventsReceiving(eventsToSend);
}
}
public void CheckFileEventsReceivingOnConnectedDevices()
{
var filesToTest = TestFilesProvider.GetValidFiles(
f => f.GetTrackChunks().Count() == 1,
f =>
{
var tempoMap = f.GetTempoMap();
return((TimeSpan)f.GetTimedEvents().Last().TimeAs <MetricTimeSpan>(tempoMap) < 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;
if (eventToSend.Event is SysExEvent)
{
continue;
}
eventsToSend.Add(eventToSend);
}
CheckEventsReceiving(eventsToSend);
}
}
public void Read_UseCustomBuffer(int bufferSize, bool checkData)
{
var noBufferingSettings = new ReadingSettings
{
ReaderSettings = new ReaderSettings
{
BufferingPolicy = BufferingPolicy.DontUseBuffering
}
};
var buffer = new byte[bufferSize];
var customBufferingSettings = new ReadingSettings
{
ReaderSettings = new ReaderSettings
{
BufferingPolicy = BufferingPolicy.UseCustomBuffer,
Buffer = buffer
}
};
var lastBufferData = buffer.ToArray();
Assert.IsTrue(buffer.All(b => b == 0), "Initial buffer contains non-zero bytes.");
foreach (var filePath in TestFilesProvider.GetValidFilesPaths())
{
var expectedMidiFile = MidiFile.Read(filePath, noBufferingSettings);
var midiFile = MidiFile.Read(filePath, customBufferingSettings);
MidiAsserts.AreFilesEqual(expectedMidiFile, midiFile, true, $"File '{filePath}' is invalid.");
if (checkData)
{
CollectionAssert.AreNotEqual(lastBufferData, buffer, "Buffer contains the same data after reading a file.");
lastBufferData = buffer.ToArray();
}
}
}
public void ReadFileWithoutNotesReadingHandler()
{
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events());
var notes = midiFile.GetNotes();
}
public void ReadFileWithoutTempoMapReadingHandler()
{
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events());
var tempoMap = midiFile.GetTempoMap();
}
public void ReadFileWithoutTimedEventsReadingHandler()
{
var midiFile = MidiFile.Read(TestFilesProvider.GetMiscFile_14000events());
var timedEvents = midiFile.GetTimedEvents();
}