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"); }