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