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 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.");
}
}
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 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 Write_WriteHeaderChunk()
{
var midiFile = new MidiFile(
new TrackChunk(
new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50),
new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)50)));
Write(
midiFile,
settings => { },
(fileInfo1, fileInfo2) =>
{
var originalMidiFile = MidiFile.Read(fileInfo1.FullName);
var newMidiFile = MidiFile.Read(fileInfo2.FullName);
MidiAsserts.AreFilesEqual(originalMidiFile, newMidiFile, true, "New file 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}'.");
}
}
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 Write_DifferentDeltaTimes()
{
var originalMidiEvents = new MidiEvent[]
{
new TextEvent("A")
{
DeltaTime = 0
},
new TextEvent("B")
{
DeltaTime = 10
},
new TextEvent("C")
{
DeltaTime = 100
},
new TextEvent("D")
{
DeltaTime = 1000
},
new TextEvent("E")
{
DeltaTime = 10000
},
new TextEvent("F")
{
DeltaTime = 100000
}
};
var midiFile = new MidiFile(new TrackChunk(originalMidiEvents));
Write(
midiFile,
settings => { },
(fileInfo1, fileInfo2) =>
{
var newMidiFile = MidiFile.Read(fileInfo2.FullName);
MidiAsserts.AreFilesEqual(midiFile, newMidiFile, false, "File is invalid.");
});
}
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 Write_DontWriteHeaderChunk()
{
var midiFile = new MidiFile(
new TrackChunk(
new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50),
new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)50)));
Write(
midiFile,
settings => settings.WriteHeaderChunk = false,
(fileInfo1, fileInfo2) =>
{
var originalMidiFile = MidiFile.Read(fileInfo1.FullName);
Assert.Throws <NoHeaderChunkException>(() => MidiFile.Read(fileInfo2.FullName));
var newMidiFile = MidiFile.Read(fileInfo2.FullName, new ReadingSettings
{
NoHeaderChunkPolicy = NoHeaderChunkPolicy.Ignore
});
MidiAsserts.AreFilesEqual(originalMidiFile, newMidiFile, false, "New file is invalid.");
});
}
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();
}
}
}
