midi-nibbler 0.1.1 → 0.2.1

data/test/{test_parser_buffer.rb → parser_buffer_test.rb}

@@ -1,11 +1,6 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
-
-class BufferTest < Test::Unit::TestCase
-
-  include Nibbler
-  include TestHelper
+class Nibbler::BufferTest < Test::Unit::TestCase
 
   def test_buffer_nibble_str
     nibbler = Nibbler.new
@@ -68,4 +63,4 @@ class BufferTest < Test::Unit::TestCase
     assert_equal(["9", "4", "0"], nibbler.buffer)    
   end
     
-end
+end

data/test/{test_parser_rejected.rb → parser_rejected_test.rb}

@@ -1,16 +1,11 @@
-#!/usr/bin/env ruby
-
 require "helper"
 
-class ParserRejectedTest < Test::Unit::TestCase
-
-  include Nibbler
-  include TestHelper
+class Nibbler::ParserRejectedTest < Test::Unit::TestCase
   
   def test_leading_chars
     nibbler = Nibbler.new
     msg = nibbler.parse("0", "9", "04", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)        
+    assert_equal(::MIDIMessage::NoteOn, msg.class)        
     assert_equal(["0"], nibbler.rejected)   
   end
 
@@ -23,43 +18,43 @@ class ParserRejectedTest < Test::Unit::TestCase
   def test_leading_string
     nibbler = Nibbler.new
     msg = nibbler.parse("10", "9", "04", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["1", "0"], nibbler.rejected)
   end
   
   def test_long_leading_string
     nibbler = Nibbler.new
     msg = nibbler.parse("000001000010", "9", "04", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal("000001000010".split(//), nibbler.rejected)
   end
   
   def test_long_leading_string_overlap
     nibbler = Nibbler.new
     msg = nibbler.parse("000001000010090", "4", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal("0000010000100".split(//), nibbler.rejected)
   end
 
   def test_leading_number
     nibbler = Nibbler.new
     msg = nibbler.parse(0x30, "9", "04", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["3", "0"], nibbler.rejected)
   end
 
   def test_2_leading_numbers
     nibbler = Nibbler.new
     msg = nibbler.parse(0x60, 0x30, "9", "04", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["6", "0", "3", "0"], nibbler.rejected)
   end
   
   def test_3_leading_numbers
     nibbler = Nibbler.new
     msg = nibbler.parse(0x00, 0x30, "9", "04", "040")
-    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["0", "0", "3", "0"], nibbler.rejected)
   end  
   
-end
+end

data/test/parser_test.rb

@@ -0,0 +1,188 @@
+require "helper"
+
+class Nibbler::ParserTest < Test::Unit::TestCase
+  
+  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
+    
+  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
+  
+  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
+  
+  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
+  
+  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 }
+    
+    assert_nil output     
+    assert_equal(["9", "0", "4"], parser.instance_variable_get("@current"))
+  end
+  
+  def test_process
+    parser = Nibbler::Parser.new
+    short = ["9", "0", "4", "0", "5", "0", "5", "0"]
+    output = parser.send(:process, short)
+    
+    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
+  
+  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)
+    
+    assert_not_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
+  
+  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"]
+    
+    output = parser.send(:process, short)
+
+    assert_not_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])
+    
+    output2 = parser.send(:process, short2)
+
+    assert_not_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
+
+  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)
+
+    assert_nil output
+    assert_equal(["5", "0", "9", "0", "4", "0", "5", "0"], parser.buffer)
+  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)
+
+    assert_not_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
+  
+  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)
+
+    assert_not_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
+  
+  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)
+
+    assert_not_nil output
+    assert_equal(::MIDIMessage::NoteOn, output[:message].class)
+    
+    running_status = ["5", "0", "6", "0"]
+    parser.instance_variable_set("@buffer", running_status)
+    parser.send(:populate_current)
+    output = parser.send(:nibbles_to_message)
+
+    assert_not_nil output
+    assert_equal(::MIDIMessage::NoteOn, output[:message].class)
+    assert_equal(["5", "0", "6", "0"], output[:processed])
+  end
+  
+  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)
+
+    assert_not_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  
+  
+  def test_message_library
+    parser = nil
+    assert_nothing_raised Exception do
+      parser = Nibbler::Parser.new(:message_lib => :midilib)
+    end
+    assert_equal Nibbler::Midilib, parser.instance_variable_get("@message")
+
+    assert_nothing_raised Exception do
+      parser = Nibbler::Parser.new
+    end
+    assert_equal Nibbler::MIDIMessage, parser.instance_variable_get("@message")
+  end
+            
+end

data/test/session_test.rb

@@ -0,0 +1,135 @@
+require "helper"
+
+class Nibbler::SessionTest < Test::Unit::TestCase
+    
+  def test_varying_length_strings
+    session = Nibbler::Session.new
+    message = session.parse("9", "04", "040")
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::NoteOn, message.class)
+  end
+  
+  def test_note_off
+    session = Nibbler::Session.new
+    message = session.parse(0x80, 0x40, 0x40)
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::NoteOff, message.class)
+    assert_equal(0, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)  
+  end
+  
+  def test_note_on
+    session = Nibbler::Session.new
+    message = session.parse(0x90, 0x40, 0x40)
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::NoteOn, message.class)
+    assert_equal(0, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)  
+  end  
+  
+  def test_timestamp
+    session = Nibbler::Session.new
+    stamp = Time.now.to_i
+    report = session.parse(0x90, 0x40, 0x40, :timestamp => stamp)
+    message = report[:messages]
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::NoteOn, message.class)
+    assert_equal(0, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)
+    assert_equal(stamp, report[:timestamp])      
+  end
+  
+  def test_polyphonic_aftertouch
+    session = Nibbler::Session.new
+    message = session.parse(0xA1, 0x40, 0x40)
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::PolyphonicAftertouch, message.class)
+    assert_equal(1, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.value)      
+  end  
+  
+  def test_control_change
+    session = Nibbler::Session.new
+    message = session.parse(0xB2, 0x20, 0x20)
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::ControlChange, message.class)
+    assert_equal(message.channel, 2)
+    assert_equal(0x20, message.index)
+    assert_equal(0x20, message.value)    
+  end
+  
+  def test_program_change
+    session = Nibbler::Session.new
+    message = session.parse(0xC3, 0x40)
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::ProgramChange, message.class)
+    assert_equal(3, message.channel)
+    assert_equal(0x40, message.program)  
+  end
+  
+  def test_channel_aftertouch
+    session = Nibbler::Session.new
+    message = session.parse(0xD3, 0x50)
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::ChannelAftertouch, message.class)
+    assert_equal(3, message.channel)
+    assert_equal(0x50, message.value)  
+  end  
+    
+  def test_pitch_bend
+    session = Nibbler::Session.new
+    message = session.parse(0xE0, 0x20, 0x00) # center
+
+    assert_not_nil message
+    assert_equal(MIDIMessage::PitchBend, message.class)
+    assert_equal(0, message.channel)
+    assert_equal(0x20, message.low)
+    assert_equal(0x00, message.high)  
+  end   
+   
+  def test_system_common_generic_3_bytes
+    session = Nibbler::Session.new
+    message = session.parse(0xF1, 0x50, 0xA0)
+
+    assert_not_nil message
+    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    
+
+  def test_system_common_generic_2_bytes
+    session = Nibbler::Session.new
+    message = session.parse(0xF1, 0x50)
+    assert_equal(MIDIMessage::SystemCommon, message.class)
+    assert_equal(1, message.status[1])
+    assert_equal(0x50, message.data[0])  
+  end    
+
+  def test_system_common_generic_1_byte
+    session = Nibbler::Session.new
+    message = session.parse(0xF1)
+    assert_equal(MIDIMessage::SystemCommon, message.class)
+    assert_equal(1, message.status[1])
+  end    
+  
+  def test_system_realtime
+    session = Nibbler::Session.new
+    message = session.parse(0xF8)
+    assert_equal(MIDIMessage::SystemRealtime, message.class)
+    assert_equal(8, message.id)
+  end
+                 
+end

data/test/{test_type_conversion.rb → type_conversion_test.rb}

@@ -1,15 +1,10 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
-
-class TypeConversionTest < Test::Unit::TestCase
-
-  include Nibbler
-  include TestHelper
+class Nibbler::TypeConversionTest < Test::Unit::TestCase
   
   def test_hex_chars_to_numeric_bytes  
     nibbles = ["4", "5", "9", "3"]
-    bytes = TypeConversion.hex_chars_to_numeric_bytes(nibbles)
+    bytes = Nibbler::TypeConversion.hex_chars_to_numeric_bytes(nibbles)
     
     assert_equal(["4", "5", "9", "3"], nibbles)
     assert_equal([0x45, 0x93], bytes) 
@@ -17,7 +12,7 @@ class TypeConversionTest < Test::Unit::TestCase
   
   def test_hex_str_to_hex_chars
     str = "904050"
-    nibbles = TypeConversion.send(:hex_str_to_hex_chars, str)
+    nibbles = Nibbler::TypeConversion.send(:hex_str_to_hex_chars, str)
     
     assert_equal("904050", str)
     assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)    
@@ -25,10 +20,10 @@ class TypeConversionTest < Test::Unit::TestCase
   
   def test_numeric_byte_to_hex_chars
     num = 0x90
-    nibbles = TypeConversion.send(:numeric_byte_to_hex_chars, num)
+    nibbles = Nibbler::TypeConversion.send(:numeric_byte_to_hex_chars, num)
     
     assert_equal(0x90, num)
     assert_equal(["9", "0"], nibbles)     
   end         
               
-end
+end