midi-nibbler 0.2.3 → 0.2.4

data/test/helper.rb

@@ -2,4 +2,6 @@ dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + "/../lib"
 
 require "minitest/autorun"
+require "mocha/test_unit"
+require "shoulda-context"
 require "nibbler"

data/test/message_library_test.rb

@@ -0,0 +1,37 @@
+require "helper"
+
+class Nibbler::MessageLibraryTest < Minitest::Test
+
+  context "MessageLibrary" do
+
+    context ".adapter" do
+
+      context "Midilib" do
+
+        setup do
+          @adapter = Nibbler::MessageLibrary.adapter(:midilib)
+        end
+
+        should "set to midilib" do
+          assert_equal Nibbler::Midilib, @adapter
+        end
+
+      end
+
+      context "MIDIMessage" do
+
+        setup do
+          @adapter = Nibbler::MessageLibrary.adapter(:midi_message)
+        end
+
+        should "set to midi message" do
+          assert_equal Nibbler::MIDIMessage, @adapter
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/midi_message_test.rb

@@ -3,124 +3,220 @@ require "nibbler/midi-message"
 
 class Nibbler::MIDIMessageTest < Minitest::Test
 
-  def test_note_off
-    lib = Nibbler::MIDIMessage
-    message = lib.note_off(0, 0x40, 0x40)
-    assert_equal(MIDIMessage::NoteOff, message.class)
-    assert_equal(0, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-  end
+  context "MIDIMessage" do
 
-  def test_note_on
-    lib = Nibbler::MIDIMessage
-    message = lib.note_on(0x0, 0x40, 0x40)
-    assert_equal(MIDIMessage::NoteOn, message.class)
-    assert_equal(0, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-  end
+    setup do
+      @lib = Nibbler::MIDIMessage
+    end
 
-  def test_polyphonic_aftertouch
-    lib = Nibbler::MIDIMessage
-    message = lib.polyphonic_aftertouch(0x1, 0x40, 0x40)
-    assert_equal(MIDIMessage::PolyphonicAftertouch, message.class)
-    assert_equal(1, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.value)
-  end
+    context "note off" do
 
-  def test_control_change
-    lib = Nibbler::MIDIMessage
-    message = lib.control_change(0x2, 0x20, 0x20)
-    assert_equal(MIDIMessage::ControlChange, message.class)
-    assert_equal(message.channel, 2)
-    assert_equal(0x20, message.index)
-    assert_equal(0x20, message.value)
-  end
+      setup do
+        @message = @lib.note_off(0, 0x40, 0x40)
+      end
 
-  def test_program_change
-    lib = Nibbler::MIDIMessage
-    message = lib.program_change(0x3, 0x40)
-    assert_equal(MIDIMessage::ProgramChange, message.class)
-    assert_equal(3, message.channel)
-    assert_equal(0x40, message.program)
-  end
+      should "create correct message" do
+        assert_equal(MIDIMessage::NoteOff, @message.class)
+        assert_equal(0, @message.channel)
+        assert_equal(0x40, @message.note)
+        assert_equal(0x40, @message.velocity)
+      end
 
-  def test_channel_aftertouch
-    lib = Nibbler::MIDIMessage
-    message = lib.channel_aftertouch(0x3, 0x50)
-    assert_equal(MIDIMessage::ChannelAftertouch, message.class)
-    assert_equal(3, message.channel)
-    assert_equal(0x50, message.value)
-  end
+    end
 
-  def test_pitch_bend
-    lib = Nibbler::MIDIMessage
-    message = lib.pitch_bend(0x0, 0x20, 0x00) # center
-    assert_equal(MIDIMessage::PitchBend, message.class)
-    assert_equal(0, message.channel)
-    assert_equal(0x20, message.low)
-    assert_equal(0x00, message.high)
-  end
+    context "note on" do
 
-  def test_system_exclusive_command
-    lib = Nibbler::MIDIMessage
-    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-    assert_equal(MIDIMessage::SystemExclusive::Command, message.class)
-    assert_equal([0xF0, [0x41, 0x10, 0x42], 0x12, [0x40, 0x00, 0x7F], [0x00], 0x41, 0xF7], message.to_a)
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], message.to_bytes)
-    assert_equal("F04110421240007F0041F7", message.to_hex_s)
-  end
+      setup do
+        @message = @lib.note_on(0x0, 0x40, 0x40)
+      end
 
-  def test_system_exclusive_request
-    lib = Nibbler::MIDIMessage
-    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-    assert_equal(MIDIMessage::SystemExclusive::Request, message.class)
-    assert_equal([0xF0, [0x41, 0x10, 0x42], 0x11, [0x40, 0x00, 0x7F], [0x00, 0x00, 0x00], 0x41, 0xF7], message.to_a)
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x41, 0xF7], message.to_bytes)
-    assert_equal("F04110421140007F00000041F7", message.to_hex_s)
-  end
+      should "create correct message" do
+        assert_equal(MIDIMessage::NoteOn, @message.class)
+        assert_equal(0, @message.channel)
+        assert_equal(0x40, @message.note)
+        assert_equal(0x40, @message.velocity)
+      end
 
-  def test_system_exclusive_node
-    lib = Nibbler::MIDIMessage
-    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-    node = message.node
-    assert_equal(MIDIMessage::SystemExclusive::Node, node.class)
-    assert_equal(0x41, node.manufacturer_id)
-    assert_equal(0x42, node.model_id)
-    assert_equal(0x10, node.device_id)
-  end
+    end
 
-  def test_system_common_generic_3_bytes
-    lib = Nibbler::MIDIMessage
-    message = lib.system_common(0x1, 0x50, 0xA0)
-    assert_equal(MIDIMessage::SystemCommon, message.class)
-    assert_equal(1, message.status[1])
-    assert_equal(0x50, message.data[0])
-    assert_equal(0xA0, message.data[1])
-  end
+    context "polyphonic aftertouch" do
 
-  def test_system_common_generic_2_bytes
-    nibbler = Nibbler.new
-    message = nibbler.parse(0xF1, 0x50)
-    assert_equal(MIDIMessage::SystemCommon, message.class)
-    assert_equal(1, message.status[1])
-    assert_equal(0x50, message.data[0])
-  end
+      setup do
+        @message = @lib.polyphonic_aftertouch(0x1, 0x40, 0x40)
+      end
 
-  def test_system_common_generic_1_byte
-    nibbler = Nibbler.new
-    message = nibbler.parse(0xF1)
-    assert_equal(MIDIMessage::SystemCommon, message.class)
-    assert_equal(1, message.status[1])
-  end
+      should "create correct message" do
+        assert_equal(MIDIMessage::PolyphonicAftertouch, @message.class)
+        assert_equal(1, @message.channel)
+        assert_equal(0x40, @message.note)
+        assert_equal(0x40, @message.value)
+      end
+
+    end
+
+    context "control change" do
+
+      setup do
+        @message = @lib.control_change(0x2, 0x20, 0x20)
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::ControlChange, @message.class)
+        assert_equal(@message.channel, 2)
+        assert_equal(0x20, @message.index)
+        assert_equal(0x20, @message.value)
+      end
+
+    end
+
+    context "program change" do
+
+      setup do
+        @message = @lib.program_change(0x3, 0x40)
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::ProgramChange, @message.class)
+        assert_equal(3, @message.channel)
+        assert_equal(0x40, @message.program)
+      end
+
+    end
+
+    context "channel aftertouch" do
+
+      setup do
+        @message = @lib.channel_aftertouch(0x3, 0x50)
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::ChannelAftertouch, @message.class)
+        assert_equal(3, @message.channel)
+        assert_equal(0x50, @message.value)
+      end
+
+    end
+
+    context "pitch bend" do
+
+      setup do
+        @message = @lib.pitch_bend(0x0, 0x20, 0x00) # center
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::PitchBend, @message.class)
+        assert_equal(0, @message.channel)
+        assert_equal(0x20, @message.low)
+        assert_equal(0x00, @message.high)
+      end
+
+    end
+
+    context "system exclusive command" do
+
+      setup do
+        @message = @lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::SystemExclusive::Command, @message.class)
+        assert_equal([0xF0, [0x41, 0x10, 0x42], 0x12, [0x40, 0x00, 0x7F], [0x00], 0x41, 0xF7], @message.to_a)
+        assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], @message.to_bytes)
+        assert_equal("F04110421240007F0041F7", @message.to_hex_s)
+      end
+
+    end
+
+    context "system exclusive request" do
+
+      setup do
+        @message = @lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::SystemExclusive::Request, @message.class)
+        assert_equal([0xF0, [0x41, 0x10, 0x42], 0x11, [0x40, 0x00, 0x7F], [0x00, 0x00, 0x00], 0x41, 0xF7], @message.to_a)
+        assert_equal([0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x41, 0xF7], @message.to_bytes)
+        assert_equal("F04110421140007F00000041F7", @message.to_hex_s)
+      end
+
+    end
+
+    context "system exclusive node" do
+
+      setup do
+        @message = @lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
+        @node = @message.node
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::SystemExclusive::Node, @node.class)
+        assert_equal(0x41, @node.manufacturer_id)
+        assert_equal(0x42, @node.model_id)
+        assert_equal(0x10, @node.device_id)
+      end
+
+    end
+
+    context "system realtime" do
+
+      setup do
+        @message = @lib.system_realtime(0x8)
+      end
+
+      should "create correct message" do
+        assert_equal(MIDIMessage::SystemRealtime, @message.class)
+        assert_equal(8, @message.id)
+      end
+
+    end
+
+    context "system common" do
+
+      context "1 byte" do
+
+        setup do
+          @message = @lib.system_common(0x1)
+        end
+
+        should "create correct message" do
+          assert_equal(MIDIMessage::SystemCommon, @message.class)
+          assert_equal(1, @message.status[1])
+        end
+
+      end
+
+      context "2 bytes" do
+
+        setup do
+          @message = @lib.system_common(0x1, 0x50)
+        end
+
+        should "create correct message" do
+          assert_equal(MIDIMessage::SystemCommon, @message.class)
+          assert_equal(1, @message.status[1])
+          assert_equal(0x50, @message.data[0])
+        end
+
+      end
+
+      context "3 bytes" do
+
+        setup do
+          @message = @lib.system_common(0x1, 0x50, 0xA0)
+        end
+
+        should "create correct message" do
+          assert_equal(MIDIMessage::SystemCommon, @message.class)
+          assert_equal(1, @message.status[1])
+          assert_equal(0x50, @message.data[0])
+          assert_equal(0xA0, @message.data[1])
+        end
+
+      end
+
+    end
 
-  def test_system_realtime
-    nibbler = Nibbler.new
-    message = nibbler.parse(0xF8)
-    assert_equal(MIDIMessage::SystemRealtime, message.class)
-    assert_equal(8, message.id)
   end
 
 end

data/test/parser_test.rb

@@ -2,182 +2,254 @@ require "helper"
 
 class Nibbler::ParserTest < Minitest::Test
 
-  def test_lookahead
-    parser = Nibbler::Parser.new
-    num = 6
-    parser.instance_variable_set("@buffer", ["9", "0", "4", "0", "5", "0"])
-    parser.send(:populate_current)
-    output = parser.send(:lookahead, num) { |nibble_2, bytes| [nibble_2, bytes] }
-    assert_equal([0,[0x90, 0x40, 0x50]], output[:message])
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
-    assert_equal([], parser.instance_variable_get("@current"))
-  end
+  context "Parser" do
 
-  def test_lookahead_trailing
-    parser = Nibbler::Parser.new
-    num = 6
-    parser.instance_variable_set("@buffer", ["9", "0", "4", "0", "5", "0", "5", "0"])
-    parser.send(:populate_current)
-    output = parser.send(:lookahead, num) { |nibble_2, bytes| [nibble_2, bytes] }
-    assert_equal([0,[0x90, 0x40, 0x50]], output[:message])
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
-    assert_equal(["5", "0"], parser.instance_variable_get("@current"))
-  end
+    setup do
+      @library = Nibbler::MessageLibrary.adapter
+      @parser = Nibbler::Parser.new(@library)
+    end
+
+    context "#lookahead" do
+
+      context "basic" do
+
+        setup do
+          @parser.instance_variable_set("@buffer", ["9", "0", "4", "0", "5", "0"])
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:lookahead, fragment, Nibbler::MessageBuilder.for_channel_message(@library, 0x9))
+        end
+
+        should "return proper message" do
+          assert_equal([0x90, 0x40, 0x50], @output[:message].to_a)
+          assert_equal(["9", "0", "4", "0", "5", "0"], @output[:processed])
+        end
+
+      end
+
+      context "with trailing nibbles" do
+
+        setup do
+          @parser.instance_variable_set("@buffer", ["9", "0", "4", "0", "5", "0", "5", "0"])
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:lookahead, fragment, Nibbler::MessageBuilder.for_channel_message(@library, 0x9))
+        end
+
+        should "disregard trailing nibbles and return proper messages" do
+          assert_equal([0x90, 0x40, 0x50], @output[:message].to_a)
+          assert_equal(["9", "0", "4", "0", "5", "0"], @output[:processed])
+        end
+
+      end
+
+      context "incomplete" do
+
+        setup do
+          @parser.instance_variable_set("@buffer", ["9", "0", "4"])
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:lookahead, fragment, Nibbler::MessageBuilder.for_channel_message(@library, 0x9))
+        end
+
+        should "not return anything" do
+          assert_nil @output
+        end
+
+      end
 
-  def test_lookahead_too_short
-    parser = Nibbler::Parser.new
-    num = 6
-    parser.instance_variable_set("@buffer", ["9", "0", "4"])
-    parser.send(:populate_current)
-    output = parser.send(:lookahead, num) do |nibble_2, bytes|
-      {
-        :message => nibble_2,
-        :processed => bytes
-      }
     end
 
-    assert_nil output
-    assert_equal(["9", "0", "4"], parser.instance_variable_get("@current"))
-  end
+    context "#lookahead_for_sysex" do
 
-  def test_lookahead_sysex
-    parser = Nibbler::Parser.new
-    parser.instance_variable_set("@buffer", "F04110421240007F0041F750".split(//))
-    parser.send(:populate_current)
-    output = parser.send(:lookahead_sysex) { |b| b }
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], output[:message])
-    assert_equal("F04110421240007F0041F7".split(//), output[:processed])
-    assert_equal(["5", "0"], parser.instance_variable_get("@current"))
-  end
+      context "basic" do
 
-  def test_lookahead_sysex_too_short
-    parser = Nibbler::Parser.new
-    parser.instance_variable_set("@buffer", ["9", "0", "4"])
-    parser.send(:populate_current)
-    output = parser.send(:lookahead_sysex) { |b| b }
+        setup do
+          @parser.instance_variable_set("@buffer", "F04110421240007F0041F750".split(//))
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:lookahead_for_sysex, fragment)
+        end
 
-    assert_nil output
-    assert_equal(["9", "0", "4"], parser.instance_variable_get("@current"))
-  end
+        should "return proper message" do
+          assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], @output[:message].to_a.flatten)
+          assert_equal("F04110421240007F0041F7".split(//), @output[:processed])
+        end
 
-  def test_process
-    parser = Nibbler::Parser.new
-    short = ["9", "0", "4", "0", "5", "0", "5", "0"]
-    output = parser.send(:process, short)
+      end
 
-    assert_equal(::MIDIMessage::NoteOn, output[:messages].first.class)
-    assert_equal(["5", "0"], parser.buffer)
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
-  end
+      context "incomplete" do
 
-  def test_process_running_status
-    parser = Nibbler::Parser.new
-    two_msgs = ["9", "0", "4", "0", "5", "0", "4", "0", "6", "0"]
-    output = parser.send(:process, two_msgs)
+        setup do
+          @parser.instance_variable_set("@buffer", ["9", "0", "4"])
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:lookahead_for_sysex, fragment)
+        end
 
-    refute_nil output
-    assert_equal(::MIDIMessage::NoteOn, output[:messages][0].class)
-    #assert_equal(::MIDIMessage::NoteOn, output[:messages][1].class)
-    assert_equal([], parser.buffer)
-    assert_equal(["9", "0", "4", "0", "5", "0", "4", "0", "6", "0"], output[:processed])
-  end
+        should "not return anything" do
+          assert_nil @output
+        end
 
-  def test_process_multiple_overlapping_calls
-    parser = Nibbler::Parser.new
-    short = ["9", "0", "4", "0", "5", "0", "9", "0"]
-    short2 = ["3", "0", "2", "0", "1", "0"]
+      end
+    end
 
-    output = parser.send(:process, short)
+    context "#process" do
 
-    refute_nil output
-    assert_equal(::MIDIMessage::NoteOn, output[:messages].first.class)
-    assert_equal(["9", "0"], parser.buffer)
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
+      context "basic" do
 
-    output2 = parser.send(:process, short2)
+        setup do
+          short = ["9", "0", "4", "0", "5", "0", "5", "0"]
+          @output = @parser.send(:process, short)
+        end
 
-    refute_nil output2
-    assert_equal(::MIDIMessage::NoteOn, output2[:messages].first.class)
-    assert_equal(["1", "0"], parser.buffer)
-    assert_equal(["9", "0", "3", "0", "2", "0"], output2[:processed])
-  end
+        should "return proper message" do
+          assert_equal(::MIDIMessage::NoteOn, @output[:messages].first.class)
+          assert_equal(["9", "0", "4", "0", "5", "0"], @output[:processed])
+        end
 
-  def test_nibbles_to_message_leading
-    parser = Nibbler::Parser.new
-    short = ["5", "0", "9", "0", "4", "0", "5", "0"]
-    parser.instance_variable_set("@buffer", short)
-    parser.send(:populate_current)
-    output = parser.send(:nibbles_to_message)
+        should "have trailing nibbles in buffer" do
+          assert_equal(["5", "0"], @parser.buffer)
+        end
 
-    assert_nil output
-    assert_equal(["5", "0", "9", "0", "4", "0", "5", "0"], parser.buffer)
-  end
+      end
 
-  def test_nibbles_to_message_trailing
-    parser = Nibbler::Parser.new
-    short = ["9", "0", "4", "0", "5", "0", "5", "0"]
-    parser.instance_variable_set("@buffer", short)
-    parser.send(:populate_current)
-    output = parser.send(:nibbles_to_message)
-
-    refute_nil output
-    assert_equal(::MIDIMessage::NoteOn, output[:message].class)
-    assert_equal(["5", "0"], parser.instance_variable_get("@current"))
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
-  end
+      context "with running status" do
 
-  def test_nibbles_to_message
-    parser = Nibbler::Parser.new
-    short = ["9", "0", "4", "0", "5", "0", "5", "0"]
-    parser.instance_variable_set("@buffer", short)
-    parser.send(:populate_current)
-    output = parser.send(:nibbles_to_message)
-
-    refute_nil output
-    assert_equal(::MIDIMessage::NoteOn, output[:message].class)
-    assert_equal(["5", "0"], parser.instance_variable_get("@current"))
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
-  end
+        setup do
+          two_msgs = ["9", "0", "4", "0", "5", "0", "4", "0", "6", "0"]
+          @output = @parser.send(:process, two_msgs)
+        end
 
-  def test_nibbles_to_message_running_status
-    parser = Nibbler::Parser.new
-    short = ["9", "0", "4", "0", "5", "0"]
-    parser.instance_variable_set("@buffer", short)
-    parser.send(:populate_current)
-    output = parser.send(:nibbles_to_message)
+        should "return proper message" do
+          refute_nil @output
+          assert_equal(::MIDIMessage::NoteOn, @output[:messages][0].class)
+          assert_equal(::MIDIMessage::NoteOn, @output[:messages][1].class)
+          assert_equal(["9", "0", "4", "0", "5", "0", "4", "0", "6", "0"], @output[:processed])
+        end
 
-    refute_nil output
-    assert_equal(::MIDIMessage::NoteOn, output[:message].class)
+        should "not have anything left in the buffer" do
+          assert_empty(@parser.buffer)
+        end
 
-    running_status = ["5", "0", "6", "0"]
-    parser.instance_variable_set("@buffer", running_status)
-    parser.send(:populate_current)
-    output = parser.send(:nibbles_to_message)
+      end
 
-    refute_nil output
-    assert_equal(::MIDIMessage::NoteOn, output[:message].class)
-    assert_equal(["5", "0", "6", "0"], output[:processed])
-  end
+      context "with multiple overlapping calls" do
 
-  def test_nibbles_to_message_sysex
-    parser = Nibbler::Parser.new
-    sysex = "F04110421240007F0041F750".split(//)
-    parser.instance_variable_set("@buffer", sysex)
-    parser.send(:populate_current)
-    output = parser.send(:nibbles_to_message)
-
-    refute_nil output
-    assert_equal(::MIDIMessage::SystemExclusive::Command, output[:message].class)
-    assert_equal(["5", "0"], parser.instance_variable_get("@current"))
-    assert_equal("F04110421240007F0041F7".split(//), output[:processed])
-  end
+        setup do
+          @short = ["9", "0", "4", "0", "5", "0", "9", "0"]
+          @short2 = ["3", "0", "2", "0", "1", "0"]
+        end
 
-  def test_message_library
-    parser = Nibbler::Parser.new(:message_lib => :midilib)
-    assert_equal Nibbler::Midilib, parser.instance_variable_get("@message")
+        should "return proper messages and have trailing nibbles in buffer" do
+          @output = @parser.send(:process, @short)
+
+          refute_nil @output
+          assert_equal(::MIDIMessage::NoteOn, @output[:messages].first.class)
+          assert_equal(["9", "0", "4", "0", "5", "0"], @output[:processed])
+          assert_equal(["9", "0"], @parser.buffer)
+
+          @output2 = @parser.send(:process, @short2)
+
+          refute_nil @output2
+          assert_equal(::MIDIMessage::NoteOn, @output2[:messages].first.class)
+          assert_equal(["9", "0", "3", "0", "2", "0"], @output2[:processed])
+          assert_equal(["1", "0"], @parser.buffer)
+        end
+
+      end
+
+    end
+
+    context "#nibbles_to_message" do
+
+      context "basic" do
+
+        setup do
+          short = ["9", "0", "4", "0", "5", "0", "5", "0"]
+          @parser.instance_variable_set("@buffer", short)
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:nibbles_to_message, fragment)
+        end
+
+        should "return proper message" do
+          refute_nil @output
+          assert_equal(::MIDIMessage::NoteOn, @output[:message].class)
+          assert_equal(["9", "0", "4", "0", "5", "0"], @output[:processed])
+        end
+
+      end
+
+      context "with leading nibbles" do
+
+        setup do
+          short = ["5", "0", "9", "0", "4", "0", "5", "0"]
+          @parser.instance_variable_set("@buffer", short)
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:nibbles_to_message, fragment)
+        end
+
+        should "not do anything" do
+          assert_nil @output
+          assert_equal(["5", "0", "9", "0", "4", "0", "5", "0"], @parser.buffer)
+        end
+
+      end
+
+      context "with trailing nibbles" do
+
+        setup do
+          short = ["9", "0", "4", "0", "5", "0", "5", "0"]
+          @parser.instance_variable_set("@buffer", short)
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:nibbles_to_message, fragment)
+        end
+
+        should "return proper message" do
+          refute_nil @output
+          assert_equal(::MIDIMessage::NoteOn, @output[:message].class)
+          assert_equal(["9", "0", "4", "0", "5", "0"], @output[:processed])
+        end
+
+      end
+
+      context "with running status" do
+
+        setup do
+          short = ["9", "0", "4", "0", "5", "0"]
+          @parser.instance_variable_set("@buffer", short)
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:nibbles_to_message, fragment)
+          refute_nil @output
+          assert_equal(::MIDIMessage::NoteOn, @output[:message].class)
+          running_status = ["5", "0", "6", "0"]
+          @parser.instance_variable_set("@buffer", running_status)
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:nibbles_to_message, fragment)
+        end
+
+        should "return proper message" do
+          refute_nil @output
+          assert_equal(::MIDIMessage::NoteOn, @output[:message].class)
+          assert_equal(["5", "0", "6", "0"], @output[:processed])
+        end
+
+      end
+
+      context "sysex" do
+
+        setup do
+          sysex = "F04110421240007F0041F750".split(//)
+          @parser.instance_variable_set("@buffer", sysex)
+          fragment = @parser.send(:get_fragment, 0)
+          @output = @parser.send(:nibbles_to_message, fragment)
+        end
+
+        should "return proper message" do
+          refute_nil @output
+          assert_equal(::MIDIMessage::SystemExclusive::Command, @output[:message].class)
+          assert_equal("F04110421240007F0041F7".split(//), @output[:processed])
+        end
+
+      end
+
+    end
 
-    parser = Nibbler::Parser.new
-    assert_equal Nibbler::MIDIMessage, parser.instance_variable_get("@message")
   end
 
 end