micromidi 0.1.3 → 0.1.4

data/test/effect_test.rb

@@ -1,14 +1,11 @@
 require "helper"
 
-class EffectTest < Test::Unit::TestCase
-
-  include MicroMIDI
-  include TestHelper
+class EffectTest < Minitest::Test
 
   def test_high_pass_note_reject
     m = MicroMIDI.message
     msg = m.note "C0"
-    outp = m.hpf msg, :note, 20   
+    outp = m.hpf msg, :note, 20
     assert_equal(12, msg.note)
     assert_equal(nil, outp)
   end
@@ -52,7 +49,7 @@ class EffectTest < Test::Unit::TestCase
     assert_equal(60, msg.note)
     assert_equal(msg, outp)
   end
-  
+
   def test_notch_note_reject
     m = MicroMIDI.message
     msg = m.note "C4"
@@ -68,7 +65,7 @@ class EffectTest < Test::Unit::TestCase
     assert_equal(60, msg.note)
     assert_equal(msg, outp)
   end
-  
+
   def test_multiband_note_reject
     m = MicroMIDI.message
     msg = m.note "C4"
@@ -84,7 +81,7 @@ class EffectTest < Test::Unit::TestCase
     assert_equal(60, msg.note)
     assert_equal(msg, outp)
   end
-  
+
   def test_multinotch_note_reject
     m = MicroMIDI.message
     msg = m.note "C4"
@@ -96,11 +93,11 @@ class EffectTest < Test::Unit::TestCase
   def test_multinotch_note_accept
     m = MicroMIDI.message
     msg = m.note "C4"
-    outp = m.mbf msg, :note, [(20..30), (40..50)], :reject => true   
+    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"
@@ -114,7 +111,7 @@ class EffectTest < Test::Unit::TestCase
     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"
@@ -128,6 +125,5 @@ class EffectTest < Test::Unit::TestCase
     outp = m.transpose msg, :velocity, -10
     assert_equal(72, msg.velocity)
   end
-  
-end
 
+end

data/test/helper.rb

@@ -1,30 +1,37 @@
 dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + "/../lib"
 
-require "test/unit"
+require "minitest/autorun"
 require "midi"
 
 module TestHelper
-  
-  def self.select_devices
-    $test_device ||= {}
+
+  extend self
+
+  def test_device
+    @test_device ||= select_devices
+  end
+
+  def select_devices
+    @test_device ||= {}
     { :input => UniMIDI::Input.all, :output => UniMIDI::Output.all }.each do |type, devs|
       puts ""
       puts "select an #{type.to_s}..."
-      while $test_device[type].nil?
+      while @test_device[type].nil?
         devs.each do |device|
           puts device.pretty_name
         end
         selection = $stdin.gets.chomp
         if selection != ""
           selection = selection.to_i
-          $test_device[type] = devs.find { |d| d.id == selection }
-          puts "selected #{selection} for #{type.to_s}" unless $test_device[type]
+          @test_device[type] = devs.find { |d| d.id == selection }
+          puts "selected #{selection} for #{type.to_s}" unless @test_device[type]
         end
       end
     end
-  end 
-     
+    @test_device
+  end
+
 end
 
 TestHelper.select_devices

data/test/input_test.rb

@@ -1,17 +1,16 @@
 require "helper"
 
-class InputTest < Test::Unit::TestCase
+class InputTest < Minitest::Test
 
   def test_thru_listeners
-    m = MicroMIDI.message($test_device[:input].open)
+    m = MicroMIDI.message(TestHelper.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)    
+    assert_equal(MIDIEye::Listener, m.state.thru_listeners.first.class)
   end
 
   def test_thru_unless
   end
-            
-end
 
+end

data/test/message_test.rb

@@ -1,15 +1,11 @@
 require "helper"
 
-class MessageTest < Test::Unit::TestCase
+class MessageTest < Minitest::Test
 
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
-  
   def test_cc
     m = MicroMIDI.message
     msg = m.cc 16, 12
-    assert_equal(ControlChange, msg.class)
+    assert_equal(MIDIMessage::ControlChange, msg.class)
     assert_equal(16, msg.index)
     assert_equal(12, msg.value)
   end
@@ -17,7 +13,7 @@ class MessageTest < Test::Unit::TestCase
   def test_channel_aftertouch
     m = MicroMIDI::IO.new
     msg = m.channel_aftertouch 2, :channel => 1
-    assert_equal(ChannelAftertouch, msg.class)
+    assert_equal(MIDIMessage::ChannelAftertouch, msg.class)
     assert_equal(1, msg.channel)
     assert_equal(2, msg.value)
   end
@@ -25,34 +21,34 @@ class MessageTest < Test::Unit::TestCase
   def test_poly_aftertouch
     m = MicroMIDI::IO.new
     msg = m.poly_aftertouch 64, 2, :channel => 1
-    assert_equal(PolyphonicAftertouch, msg.class)
+    assert_equal(MIDIMessage::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(MIDIMessage::PitchBend, msg.class)
     assert_equal(1, msg.channel)
     assert_equal(64, msg.low)
-    assert_equal(2, msg.high)    
+    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(MIDIMessage::NoteOff, msg.class)
     assert_equal(13, msg.note)
     assert_equal(9, msg.channel)
-    assert_equal(80, msg.velocity)    
+    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(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(94, msg.velocity)
   end
@@ -60,15 +56,15 @@ class MessageTest < Test::Unit::TestCase
   def test_note_on_string_no_octave
     m = MicroMIDI.message
     msg = m.note "C", :velocity => 94
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::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(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(3, msg.channel)
   end
@@ -76,46 +72,45 @@ class MessageTest < Test::Unit::TestCase
   def test_note_on_symbol
     m = MicroMIDI.message
     msg = m.note :C0
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
-    assert_equal(100, msg.velocity)    
+    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(MIDIMessage::NoteOn, msg.class)
     assert_equal(36, msg.note)
-    assert_equal(100, msg.velocity)    
+    assert_equal(100, msg.velocity)
   end
-  
+
   def test_parse
     m = MicroMIDI.message
     msg = m.parse "906040"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(96, msg.note)
-    assert_equal(0, msg.channel)    
+    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)    
+    assert_equal(MIDIMessage::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(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(3, msg.channel)
-    off_msg = m.off    
-    assert_equal(NoteOff, off_msg.class)
+    off_msg = m.off
+    assert_equal(MIDIMessage::NoteOff, off_msg.class)
     assert_equal(12, off_msg.note)
     assert_equal(3, off_msg.channel)
   end
-    
-end
 
+end

data/test/output_test.rb

@@ -1,19 +1,14 @@
 require "helper"
 
-class OutputTest < Test::Unit::TestCase
-
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
+class OutputTest < Minitest::Test
 
   def test_auto_output
-    m = MicroMIDI.message($test_device[:output].open)
+    m = MicroMIDI.message(TestHelper.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
 
+end

data/test/state_test.rb

@@ -1,22 +1,18 @@
 require "helper"
 
-class StateTest < Test::Unit::TestCase
-
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
+class StateTest < Minitest::Test
 
   def test_output_cache
     m = MicroMIDI.message
     cache = m.state.output_cache
-    
-    m.note "C0"    
+
+    m.note "C0"
     assert_equal(1, cache.size)
-    
+
     m.note "C3"
-    assert_equal(2, cache.size)    
+    assert_equal(2, cache.size)
   end
-  
+
   def test_start_time
     t1 = Time.now.to_f
     m = MicroMIDI.message
@@ -25,6 +21,5 @@ class StateTest < Test::Unit::TestCase
     assert_equal(true, t1 < t)
     assert_equal(true, t < t2)
   end
-          
-end
 
+end

data/test/sticky_test.rb

@@ -1,52 +1,48 @@
 require "helper"
 
-class StickyTest < Test::Unit::TestCase
-
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
+class StickyTest < Minitest::Test
 
   def test_channel
     m = MicroMIDI.message
     msg = m.note "C0"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::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(MIDIMessage::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(MIDIMessage::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(MIDIMessage::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(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(100, msg.velocity)
-    
-    m.velocity 10    
+
+    m.velocity 10
     msg = m.note "C0"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(10, msg.velocity)
@@ -55,38 +51,38 @@ class StickyTest < Test::Unit::TestCase
   def test_octave
     m = MicroMIDI.message
     msg = m.note "C"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(36, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(100, msg.velocity)
-    
-    m.octave 4    
+
+    m.octave 4
     msg = m.note "C"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::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(MIDIMessage::NoteOn, msg.class)
     assert_equal(36, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(100, msg.velocity)
-    
-    m.octave 4 
+
+    m.octave 4
     msg = m.note "C0"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::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(MIDIMessage::NoteOn, msg.class)
     assert_equal(14, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(100, msg.velocity)
@@ -95,38 +91,37 @@ class StickyTest < Test::Unit::TestCase
   def test_velocity_super_sticky
     m = MicroMIDI.message
     m.super_sticky
-    
+
     msg = m.note "C0"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(100, msg.velocity)
-    
-    m.velocity 10    
+
+    m.velocity 10
     msg = m.note "C0", :velocity => 20
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::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(MIDIMessage::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(MIDIMessage::SystemExclusive::Node, node.class)
     assert_equal(65, node.manufacturer_id)
     assert_equal(66, node.model_id)
     assert_equal(16, node.device_id)
-      
+
   end
-        
-end
 
+end