private NotesReadingHandler ReadWithNotesReadingHandler(MidiFile midiFile, bool sortNotes)
{
var notesReadingHandler = new NotesReadingHandler(sortNotes);
MidiFileTestUtilities.ReadUsingHandlers(midiFile, notesReadingHandler);
return(notesReadingHandler);
}
public void CompareOriginalFormat_Read_DifferentFormats()
{
var midiFile1 = MidiFileTestUtilities.Read(
new MidiFile(new TrackChunk(new NoteOnEvent {
DeltaTime = 100
})),
null,
null,
MidiFileFormat.MultiTrack);
var midiFile2 = MidiFileTestUtilities.Read(
new MidiFile(new TrackChunk(new NoteOnEvent {
DeltaTime = 100
})),
null,
null,
MidiFileFormat.SingleTrack);
var areEqual = MidiFile.Equals(
midiFile1,
midiFile2,
new MidiFileEqualityCheckSettings {
CompareOriginalFormat = true
},
out var message);
Assert.IsFalse(areEqual, "Files are equal.");
Assert.IsNotNull(message, "Message is null.");
Assert.IsNotEmpty(message, "Message is empty.");
}
private TimedEventsReadingHandler ReadWithTimedEventsReadingHandler(MidiFile midiFile, bool sortEvents)
{
var timedEventsReadingHandler = new TimedEventsReadingHandler(sortEvents);
MidiFileTestUtilities.ReadUsingHandlers(midiFile, timedEventsReadingHandler);
return(timedEventsReadingHandler);
}
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.");
}
}
public void ReadWriteCustomChunk()
{
const int expectedA = 1234567;
const string expectedB = "Test";
const byte expectedC = 45;
var customChunkTypes = new ChunkTypesCollection
{
{ typeof(CustomChunk), CustomChunk.Id }
};
var readingSettings = new ReadingSettings {
CustomChunkTypes = customChunkTypes
};
var midiFile = MidiFileTestUtilities.Read(
new MidiFile(
new TrackChunk(
new TextEvent("foo"),
new MarkerEvent("bar")),
new CustomChunk(expectedA, expectedB, expectedC)),
null,
readingSettings);
var customChunks = midiFile.Chunks.OfType <CustomChunk>().ToArray();
Assert.AreEqual(1, customChunks.Length, "Custom chunks count is invalid.");
var customChunk = customChunks.First();
Assert.AreEqual(expectedA, customChunk.A, "A value is invalid");
Assert.AreEqual(expectedB, customChunk.B, "B value is invalid");
Assert.AreEqual(expectedC, customChunk.C, "C value is invalid");
}
public void Read_Handler_Mixed()
{
var timeDivision = new TicksPerQuarterNoteTimeDivision(1000);
var handler = new MixedReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(
new MidiFile(
new TrackChunk(new TextEvent("test"), new TextEvent("test 2")),
new TrackChunk(),
new TrackChunk(new SetTempoEvent(100000)),
new TrackChunk())
{
TimeDivision = timeDivision
},
handler);
Assert.AreEqual(1, handler.FileStartHandledCount, "File: Start Handled Count is invalid.");
Assert.AreEqual(1, handler.FileEndHandledCount, "File: End Handled Count is invalid.");
Assert.AreEqual(timeDivision, handler.FileTimeDivision, "File: Time division is invalid.");
Assert.AreEqual(4, handler.TrackChunkStartHandledCount, "Track chunk: Start Handled Count is invalid.");
Assert.AreEqual(4, handler.TrackChunkContentStartHandledCount, "Track chunk: Content Start Handled Count is invalid.");
Assert.AreEqual(4, handler.TrackChunkEndHandledCount, "Track chunk: End Handled Count is invalid.");
Assert.AreEqual(3, handler.EventHandledCount, "Event: Handled Count is invalid.");
}
public void DontCompareOriginalFormat_Read(MidiFileFormat firstFormat, MidiFileFormat secondFormat)
{
var midiFile1 = MidiFileTestUtilities.Read(
new MidiFile(new TrackChunk(new NoteOnEvent {
DeltaTime = 100
})),
null,
null,
firstFormat);
var midiFile2 = MidiFileTestUtilities.Read(
new MidiFile(new TrackChunk(new NoteOnEvent {
DeltaTime = 100
})),
null,
null,
secondFormat);
var areEqual = MidiFile.Equals(
midiFile1,
midiFile2,
new MidiFileEqualityCheckSettings {
CompareOriginalFormat = false
},
out var message);
Assert.IsTrue(areEqual, "Files aren't equal.");
Assert.IsNull(message, "Message isn't null.");
}
public void Read_Handler_AllHandlers()
{
var timeDivision = new TicksPerQuarterNoteTimeDivision(1000);
var fileReadingHandler = new FileReadingHandler();
var trackChunkReadingHandler = new TrackChunkReadingHandler();
var eventReadingHandler = new EventReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(
new MidiFile(
new TrackChunk(new TextEvent("test"), new TextEvent("test 2")),
new TrackChunk(),
new TrackChunk(new SetTempoEvent(100000)),
new TrackChunk())
{
TimeDivision = timeDivision
},
fileReadingHandler,
trackChunkReadingHandler,
eventReadingHandler);
Assert.AreEqual(1, fileReadingHandler.StartHandledCount, "File: Start Handled Count is invalid.");
Assert.AreEqual(1, fileReadingHandler.EndHandledCount, "File: End Handled Count is invalid.");
Assert.AreEqual(timeDivision, fileReadingHandler.TimeDivision, "File: Time division is invalid.");
Assert.AreEqual(0, fileReadingHandler.BadHandledCount, "File: Scope wasn't used correctly.");
Assert.AreEqual(4, trackChunkReadingHandler.StartHandledCount, "Track chunk: Start Handled Count is invalid.");
Assert.AreEqual(4, trackChunkReadingHandler.ContentStartHandledCount, "Track chunk: Content Start Handled Count is invalid.");
Assert.AreEqual(4, trackChunkReadingHandler.EndHandledCount, "Track chunk: End Handled Count is invalid.");
Assert.AreEqual(0, trackChunkReadingHandler.BadHandledCount, "Track chunk: Scope wasn't used correctly.");
Assert.AreEqual(3, eventReadingHandler.HandledCount, "Event: Handled Count is invalid.");
Assert.AreEqual(0, eventReadingHandler.BadHandledCount, "Event: Scope wasn't used correctly.");
}
private TempoMapReadingHandler ReadWithTempoMapReadingHandler(MidiFile midiFile)
{
var tempoMapReadingHandler = new TempoMapReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(midiFile, tempoMapReadingHandler);
return(tempoMapReadingHandler);
}
public void Read_Handler_Event()
{
var handler = new EventReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(new MidiFile(new TrackChunk(new TextEvent("test"), new TextEvent("test 2")), new TrackChunk(), new TrackChunk(new SetTempoEvent(100000))), handler);
Assert.AreEqual(3, handler.HandledCount, "Handled Count is invalid.");
Assert.AreEqual(0, handler.BadHandledCount, "Scope wasn't used correctly.");
}
public void Read_Handler_Event_EmptyTrackChunk()
{
var handler = new EventReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(new MidiFile(new TrackChunk()), handler);
Assert.AreEqual(0, handler.HandledCount, "Handled Count is invalid.");
Assert.AreEqual(0, handler.BadHandledCount, "Scope wasn't used correctly.");
}
public void Read_Handler_TrackChunk()
{
var handler = new TrackChunkReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(new MidiFile(new TrackChunk(), new TrackChunk()), handler);
Assert.AreEqual(2, handler.StartHandledCount, "Start Handled Count is invalid.");
Assert.AreEqual(2, handler.ContentStartHandledCount, "Content Start Handled Count is invalid.");
Assert.AreEqual(2, handler.EndHandledCount, "End Handled Count is invalid.");
Assert.AreEqual(0, handler.BadHandledCount, "Scope wasn't used correctly.");
}
public void Read_Handler_File()
{
var timeDivision = new TicksPerQuarterNoteTimeDivision(1000);
var handler = new FileReadingHandler();
MidiFileTestUtilities.ReadUsingHandlers(new MidiFile {
TimeDivision = timeDivision
}, handler);
Assert.AreEqual(1, handler.StartHandledCount, "Start Handled Count is invalid.");
Assert.AreEqual(1, handler.EndHandledCount, "End Handled Count is invalid.");
Assert.AreEqual(timeDivision, handler.TimeDivision, "Time division is invalid.");
Assert.AreEqual(0, handler.BadHandledCount, "Scope wasn't used correctly.");
}
public void CheckTempoMapReadingHandler_MultipleTrackChunks_DontAllowTempoMapUsageDuringReading_AccessDuringReading()
{
var timeDivision = new TicksPerQuarterNoteTimeDivision(100);
var handler = new TempoMapReadingHandler();
var exceptionThrown = false;
try
{
var tempoMap = handler.TempoMap;
}
catch (InvalidOperationException)
{
exceptionThrown = true;
}
MidiFileTestUtilities.ReadUsingHandlers(
new MidiFile(
new TrackChunk(
new NoteOnEvent(),
new SetTempoEvent(100000),
new SetTempoEvent(150000)
{
DeltaTime = 50
},
new SetTempoEvent(200000),
new NoteOffEvent()
{
DeltaTime = 100
},
new TimeSignatureEvent(3, 4)),
new TrackChunk(
new SetTempoEvent(300000)
{
DeltaTime = 50
},
new TimeSignatureEvent(5, 8)
{
DeltaTime = 1000
}))
{
TimeDivision = timeDivision
},
handler);
Assert.IsTrue(exceptionThrown, "Exception was not thrown on get during read.");
Assert.DoesNotThrow(() => { var tempoMap = handler.TempoMap; }, "Exception thrown on get after read.");
}
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 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}'.");
}
}
public void ReadWriteCustomMetaEvent()
{
const int expectedA = 1234567;
const string expectedB = "Test";
const byte expectedC = 45;
var customMetaEventTypes = new EventTypesCollection
{
{ typeof(CustomMetaEvent), 0x5A }
};
var writingSettings = new WritingSettings {
CustomMetaEventTypes = customMetaEventTypes
};
var readingSettings = new ReadingSettings {
CustomMetaEventTypes = customMetaEventTypes
};
var midiFile = MidiFileTestUtilities.Read(
new MidiFile(
new TrackChunk(
new CustomMetaEvent(expectedA, expectedB, expectedC)
{
DeltaTime = 100
},
new TextEvent("foo"),
new MarkerEvent("bar"))),
writingSettings,
readingSettings);
var customMetaEvents = midiFile.GetEvents().OfType <CustomMetaEvent>().ToArray();
Assert.AreEqual(1, customMetaEvents.Length, "Custom meta events count is invalid.");
var customMetaEvent = customMetaEvents.First();
Assert.AreEqual(100, customMetaEvent.DeltaTime, "Delta-time is invalid.");
Assert.AreEqual(expectedA, customMetaEvent.A, "A value is invalid");
Assert.AreEqual(expectedB, customMetaEvent.B, "B value is invalid");
Assert.AreEqual(expectedC, customMetaEvent.C, "C value is invalid");
}
private void Write(MidiFile midiFile, Action <WritingSettings> setupCompression, Action <FileInfo, FileInfo> fileInfosAction)
{
MidiFileTestUtilities.Write(
midiFile,
filePath =>
{
var fileInfo = new FileInfo(filePath);
var writingSettings = new WritingSettings();
setupCompression(writingSettings);
MidiFileTestUtilities.Write(
midiFile,
filePath2 =>
{
var fileInfo2 = new FileInfo(filePath2);
fileInfosAction(fileInfo, fileInfo2);
},
writingSettings);
},
new WritingSettings());
}
private void Write_Compression_Obsolete(MidiFile midiFile, CompressionPolicy compressionPolicy, Action <FileInfo, FileInfo> fileInfosAction)
{
MidiFileTestUtilities.Write(
midiFile,
filePath =>
{
var fileInfo = new FileInfo(filePath);
MidiFileTestUtilities.Write(
midiFile,
filePath2 =>
{
var fileInfo2 = new FileInfo(filePath2);
fileInfosAction(fileInfo, fileInfo2);
},
new WritingSettings {
CompressionPolicy = compressionPolicy
});
},
new WritingSettings {
CompressionPolicy = CompressionPolicy.NoCompression
});
}
