midi 0.0.7

data/test/test_effect.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class EffectTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include TestHelper
+
+  def test_high_pass_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    outp = m.hpf msg, :note, 20   
+    assert_equal(12, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_high_pass_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.hpf msg, :note, 20
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+
+  def test_low_pass_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.lpf msg, :note, 50
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_low_pass_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.lp msg, :note, 100
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+
+  def test_band_pass_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.bpf msg, :note, (20..50)
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_band_pass_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.bp msg, :note, (20..100)
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_notch_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.nf msg, :note, (20..70)
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_notch_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.nf msg, :note, (20..50)
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_multiband_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.f msg, :note, [(20..30), (40..50)]
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_multiband_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.mbf msg, :note, [(20..30), (50..70)]
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_multinotch_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.mbf msg, :note, [(20..30), (55..65)], :reject => true
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_multinotch_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.mbf msg, :note, [(20..30), (40..50)], :reject => true   
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_limit_low
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    outp = m.limit msg, :note, (20..50)
+    assert_equal(20, msg.note)
+  end
+
+  def test_limit_high
+    m = MicroMIDI.message
+    msg = m.note "C6"
+    outp = m.limit msg, :note, (20..50)
+    assert_equal(50, msg.note)
+  end
+  
+  def test_transpose_note_up
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.transpose msg, :note, 5
+    assert_equal(65, msg.note)
+  end
+
+  def test_transpose_velocity_down
+    m = MicroMIDI.message
+    msg = m.note "C4", :velocity => 82
+    outp = m.transpose msg, :velocity, -10
+    assert_equal(72, msg.velocity)
+  end
+  
+end
+

data/test/test_input.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class InputTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  def test_thru_listeners
+    m = MicroMIDI.message($test_device[:input].open)
+    m.thru
+    assert_equal(0, m.state.listeners.size)
+    assert_equal(1, m.state.thru_listeners.size)
+    assert_equal(MIDIEye::Listener, m.state.thru_listeners.first.class)    
+  end
+
+  def test_thru_unless
+  end
+            
+end
+

data/test/test_message.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class MessageTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+  
+  def test_cc
+    m = MicroMIDI.message
+    msg = m.cc 16, 12
+    assert_equal(ControlChange, msg.class)
+    assert_equal(16, msg.index)
+    assert_equal(12, msg.value)
+  end
+
+  def test_channel_aftertouch
+    m = MicroMIDI::IO.new
+    msg = m.channel_aftertouch 2, :channel => 1
+    assert_equal(ChannelAftertouch, msg.class)
+    assert_equal(1, msg.channel)
+    assert_equal(2, msg.value)
+  end
+
+  def test_poly_aftertouch
+    m = MicroMIDI::IO.new
+    msg = m.poly_aftertouch 64, 2, :channel => 1
+    assert_equal(PolyphonicAftertouch, msg.class)
+    assert_equal(1, msg.channel)
+    assert_equal(64, msg.note)
+    assert_equal(2, msg.value)
+  end
+  
+  def test_pitch_bend
+    m = MicroMIDI::IO.new
+    msg = m.pitch_bend 64, 2, :channel => 1
+    assert_equal(PitchBend, msg.class)
+    assert_equal(1, msg.channel)
+    assert_equal(64, msg.low)
+    assert_equal(2, msg.high)    
+  end
+      
+  def test_note_off
+    m = MicroMIDI.message
+    msg = m.note_off 13, :channel => 9, :velocity => 80
+    assert_equal(NoteOff, msg.class)
+    assert_equal(13, msg.note)
+    assert_equal(9, msg.channel)
+    assert_equal(80, msg.velocity)    
+  end
+
+  def test_note_on_string
+    m = MicroMIDI.message
+    msg = m.note "C0", :velocity => 94
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(94, msg.velocity)
+  end
+
+  def test_note_on_string_no_octave
+    m = MicroMIDI.message
+    msg = m.note "C", :velocity => 94
+    assert_equal(NoteOn, msg.class)
+    assert_equal(36, msg.note)
+    assert_equal(94, msg.velocity)
+  end
+  
+  def test_note_on_int
+    m = MicroMIDI.message
+    msg = m.note 12, :channel => 3
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(3, msg.channel)
+  end
+
+  def test_note_on_symbol
+    m = MicroMIDI.message
+    msg = m.note :C0
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(100, msg.velocity)    
+  end
+    
+  def test_note_on_symbol_no_octave
+    m = MicroMIDI.message
+    msg = m.note :C
+    assert_equal(NoteOn, msg.class)
+    assert_equal(36, msg.note)
+    assert_equal(100, msg.velocity)    
+  end
+  
+  def test_parse
+    m = MicroMIDI.message
+    msg = m.parse "906040"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(96, msg.note)
+    assert_equal(0, msg.channel)    
+    assert_equal(64, msg.velocity)
+  end
+  
+  def test_program_change
+    m = MicroMIDI.message
+    msg = m.program_change 15
+    assert_equal(ProgramChange, msg.class)
+    assert_equal(15, msg.program)    
+  end
+  
+  def test_off
+    m = MicroMIDI.message
+    msg = m.note "C0", :channel => 3
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(3, msg.channel)
+    off_msg = m.off    
+    assert_equal(NoteOff, off_msg.class)
+    assert_equal(12, off_msg.note)
+    assert_equal(3, off_msg.channel)
+  end
+    
+end
+

data/test/test_output.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class OutputTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  def test_auto_output
+    m = MicroMIDI.message($test_device[:output].open)
+    assert_equal(true, m.state.auto_output)
+    m.output false
+    assert_equal(false, m.state.auto_output)
+    m.output true
+    assert_equal(true, m.state.auto_output)
+  end
+            
+end
+

data/test/test_state.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class StateTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  def test_output_cache
+    m = MicroMIDI.message
+    cache = m.state.output_cache
+    
+    m.note "C0"    
+    assert_equal(1, cache.size)
+    
+    m.note "C3"
+    assert_equal(2, cache.size)    
+  end
+  
+  def test_start_time
+    t1 = Time.now.to_f
+    m = MicroMIDI.message
+    t2 = Time.now.to_f
+    t = m.state.start_time
+    assert_equal(true, t1 < t)
+    assert_equal(true, t < t2)
+  end
+          
+end
+

data/test/test_sticky.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class StickyTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  def test_channel
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+    
+    m.channel 7
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(7, msg.channel)
+  end
+  
+  def test_channel_override
+    m = MicroMIDI.message
+    m.channel 7
+    msg = m.note "C0", :channel => 3
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(3, msg.channel)
+    assert_equal(100, msg.velocity)
+    
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(7, msg.channel)
+    assert_equal(100, msg.velocity)
+  end
+  
+  def test_velocity
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+    
+    m.velocity 10    
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(10, msg.velocity)
+  end
+
+  def test_octave
+    m = MicroMIDI.message
+    msg = m.note "C"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(36, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+    
+    m.octave 4    
+    msg = m.note "C"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(60, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+  end
+  
+  def test_octave_super_sticky
+    m = MicroMIDI.message
+    m.super_sticky
+    
+    msg = m.note "C"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(36, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+    
+    m.octave 4 
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+    
+    msg = m.note "D"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(14, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+  end
+
+  def test_velocity_super_sticky
+    m = MicroMIDI.message
+    m.super_sticky
+    
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(100, msg.velocity)
+    
+    m.velocity 10    
+    msg = m.note "C0", :velocity => 20
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(20, msg.velocity)
+    
+    msg = m.note "C1"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(24, msg.note)
+    assert_equal(0, msg.channel)
+    assert_equal(20, msg.velocity)
+  end
+  
+  def test_sysex_node
+    m = MicroMIDI.message
+    assert_equal(nil, m.sysex_node)
+    
+    node = m.node 0x41, :model_id => 0x42, :device_id => 0x10
+    assert_equal(SystemExclusive::Node, node.class)
+    assert_equal(65, node.manufacturer_id)
+    assert_equal(66, node.model_id)
+    assert_equal(16, node.device_id)
+      
+  end
+        
+end
+