midi-message 0.4.4 → 0.4.5

data/lib/midi-message/system_message.rb

@@ -4,7 +4,7 @@ module MIDIMessage
   module SystemMessage
 
     def self.included(base)
-      base.send(:include, ShortMessage)
+      base.send(:include, Message)
     end
 
     # In the case of something like SystemCommon.new(0xF2, 0x00, 0x08), the first nibble F is redundant because
@@ -17,5 +17,5 @@ module MIDIMessage
     end
 
   end
-    
+
 end

data/test/constants_test.rb

@@ -1,48 +1,43 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
+class ConstantsTest < Minitest::Test
 
-class ConstantsTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include TestHelper        
-   
   def test_note_on
-    msg = NoteOn["c3"].new(0, 100)
-    assert_equal(NoteOn, msg.class)
+    msg = MIDIMessage::NoteOn["c3"].new(0, 100)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal("C3", msg.name)
     assert_equal("C", msg.note_name)
-    assert_equal([0x90, 0x30, 100], msg.to_a)  
-  end 
-  
+    assert_equal([0x90, 0x30, 100], msg.to_a)
+  end
+
   def test_control_change
-    msg = NoteOn["C3"].new(0, 100)
-    assert_equal(NoteOn, msg.class)
+    msg = MIDIMessage::NoteOn["C3"].new(0, 100)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal("C3", msg.name)
-    assert_equal([0x90, 0x30, 100], msg.to_a)      
+    assert_equal([0x90, 0x30, 100], msg.to_a)
   end
-  
+
   def test_control_change
-    msg = ControlChange["Modulation Wheel"].new(2, 0x20)
-    assert_equal(ControlChange, msg.class)
+    msg = MIDIMessage::ControlChange["Modulation Wheel"].new(2, 0x20)
+    assert_equal(MIDIMessage::ControlChange, msg.class)
     assert_equal(msg.channel, 2)
     assert_equal(0x01, msg.index)
     assert_equal(0x20, msg.value)
-    assert_equal([0xB2, 0x01, 0x20], msg.to_a)    
+    assert_equal([0xB2, 0x01, 0x20], msg.to_a)
   end
 
   def test_system_realtime
-    msg = SystemRealtime["Stop"].new
-    assert_equal(SystemRealtime, msg.class)
+    msg = MIDIMessage::SystemRealtime["Stop"].new
+    assert_equal(MIDIMessage::SystemRealtime, msg.class)
     assert_equal("Stop", msg.name)
-    assert_equal([0xFC], msg.to_a)     
-  end  
-  
+    assert_equal([0xFC], msg.to_a)
+  end
+
   def test_system_common
-    msg = SystemCommon["Song Select"].new
-    assert_equal(SystemCommon, msg.class)
+    msg = MIDIMessage::SystemCommon["Song Select"].new
+    assert_equal(MIDIMessage::SystemCommon, msg.class)
     assert_equal("Song Select", msg.name)
-    assert_equal([0xF3], msg.to_a)      
-  end  
-  
-end
+    assert_equal([0xF3], msg.to_a)
+  end
+
+end

data/test/context_test.rb

@@ -1,10 +1,6 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
-
-class ContextTest < Test::Unit::TestCase
-
-  include TestHelper
+class ContextTest < Minitest::Test
 
   def test_note_off
     msg = MIDIMessage.with(:channel => 0, :velocity => 64) do

data/test/helper.rb

@@ -1,11 +1,6 @@
-#!/usr/bin/env ruby
-
 dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + '/../lib'
+$LOAD_PATH.unshift dir + "/../lib"
 
-require 'test/unit'
-require 'midi-message'
+require "minitest/autorun"
 
-module TestHelper
-  
-end
+require "midi-message"

data/test/{short_message_test.rb → message_test.rb}

@@ -1,53 +1,48 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
-
-class ShortMessageTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include TestHelper
+class ShortMessageTest < Minitest::Test
 
   def test_channel_message
-    msg = ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
+    msg = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
     assert_equal(0x9, msg.status[0])
     assert_equal(0x0, msg.status[1])
     assert_equal(0x40, msg.data[0])
     assert_equal(0x40, msg.data[1])
     assert_equal([0x90, 0x40, 0x40], msg.to_a)
-    assert_equal("904040", msg.to_bytestr)    
+    assert_equal("904040", msg.to_bytestr)
   end
-  
+
   def test_to_type
-    msg = ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
+    msg = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
     typemsg = msg.to_type
-    assert_equal(NoteOn, typemsg.class)
+    assert_equal(MIDIMessage::NoteOn, typemsg.class)
     assert_equal(msg.status[1], typemsg.channel)
     assert_equal(msg.data[0], typemsg.note)
     assert_equal(msg.data[1], typemsg.velocity)
     assert_equal(msg.to_a, typemsg.to_a)
-    assert_equal(msg.to_bytestr, typemsg.to_bytestr)      
+    assert_equal(msg.to_bytestr, typemsg.to_bytestr)
   end
-   
+
   def test_note_off
-    msg = NoteOff.new(0, 0x40, 0x40)
+    msg = MIDIMessage::NoteOff.new(0, 0x40, 0x40)
     assert_equal(0, msg.channel)
     assert_equal(0x40, msg.note)
     assert_equal(0x40, msg.velocity)
     assert_equal([0x80, 0x40, 0x40], msg.to_a)
     assert_equal("804040", msg.to_bytestr)
   end
-  
+
   def test_note_on
-    msg = NoteOn.new(0, 0x40, 0x40)
+    msg = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
     assert_equal(0, msg.channel)
     assert_equal(0x40, msg.note)
     assert_equal(0x40, msg.velocity)
     assert_equal([0x90, 0x40, 0x40], msg.to_a)
-    assert_equal("904040", msg.to_bytestr)  
+    assert_equal("904040", msg.to_bytestr)
   end
-  
+
   def test_note_on_to_note_off
-    msg = NoteOn.new(0, 0x40, 0x40)
+    msg = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
     assert_equal(0, msg.channel)
     assert_equal(0x40, msg.note)
     assert_equal(0x40, msg.velocity)
@@ -56,68 +51,68 @@ class ShortMessageTest < Test::Unit::TestCase
     assert_equal(0, off.channel)
     assert_equal(0x40, off.note)
     assert_equal(0x40, off.velocity)
-    assert_equal([0x80, 0x40, 0x40], off.to_a)    
-  end  
-  
-  
+    assert_equal([0x80, 0x40, 0x40], off.to_a)
+  end
+
+
   def test_polyphonic_aftertouch
-    msg = PolyphonicAftertouch.new(1, 0x40, 0x40)
+    msg = MIDIMessage::PolyphonicAftertouch.new(1, 0x40, 0x40)
     assert_equal(1, msg.channel)
     assert_equal(0x40, msg.note)
     assert_equal(0x40, msg.value)
     assert_equal([0xA1, 0x40, 0x40], msg.to_a)
-    assert_equal("A14040", msg.to_bytestr)      
-  end  
-  
+    assert_equal("A14040", msg.to_bytestr)
+  end
+
   def test_control_change
-    msg = ControlChange.new(2, 0x20, 0x20)
+    msg = MIDIMessage::ControlChange.new(2, 0x20, 0x20)
     assert_equal(msg.channel, 2)
     assert_equal(0x20, msg.index)
     assert_equal(0x20, msg.value)
     assert_equal([0xB2, 0x20, 0x20], msg.to_a)
-    assert_equal("B22020", msg.to_bytestr)    
+    assert_equal("B22020", msg.to_bytestr)
   end
-  
+
   def test_program_change
-    msg = ProgramChange.new(3, 0x40)
+    msg = MIDIMessage::ProgramChange.new(3, 0x40)
     assert_equal(3, msg.channel)
     assert_equal(0x40, msg.program)
     assert_equal([0xC3, 0x40], msg.to_a)
     assert_equal("C340", msg.to_bytestr)
-  
+
   end
-  
+
   def test_channel_aftertouch
-    msg = ChannelAftertouch.new(3, 0x50)
+    msg = MIDIMessage::ChannelAftertouch.new(3, 0x50)
     assert_equal(3, msg.channel)
     assert_equal(0x50, msg.value)
     assert_equal([0xD3, 0x50], msg.to_a)
-    assert_equal("D350", msg.to_bytestr)  
-  end  
-    
+    assert_equal("D350", msg.to_bytestr)
+  end
+
   def test_pitch_bend
     msg = MIDIMessage::PitchBend.new(0, 0x50, 0xA0)
     assert_equal(0, msg.channel)
     assert_equal(0x50, msg.low)
     assert_equal(0xA0, msg.high)
     assert_equal([0xE0, 0x50, 0xA0], msg.to_a)
-    assert_equal("E050A0", msg.to_bytestr)      
-  end   
-   
+    assert_equal("E050A0", msg.to_bytestr)
+  end
+
   def test_system_common
-    msg = SystemCommon.new(1, 0x50, 0xA0)
+    msg = MIDIMessage::SystemCommon.new(1, 0x50, 0xA0)
     assert_equal(1, msg.status[1])
     assert_equal(0x50, msg.data[0])
     assert_equal(0xA0, msg.data[1])
     assert_equal([0xF1, 0x50, 0xA0], msg.to_a)
-    assert_equal("F150A0", msg.to_bytestr)   
-  end    
-  
+    assert_equal("F150A0", msg.to_bytestr)
+  end
+
   def test_system_realtime
-    msg = SystemRealtime.new(0x8)
+    msg = MIDIMessage::SystemRealtime.new(0x8)
     assert_equal(8, msg.id)
     assert_equal([0xF8], msg.to_a)
-    assert_equal("F8", msg.to_bytestr)     
-  end        
-   
+    assert_equal("F8", msg.to_bytestr)
+  end
+
 end

data/test/mutability_test.rb

@@ -1,28 +1,23 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
+class MutabilityTest < Minitest::Test
 
-class MutabilityTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include TestHelper
-  
   def test_note
-    msg = NoteOn["E4"].new(0, 100)
+    msg = MIDIMessage::NoteOn["E4"].new(0, 100)
     assert_equal(0x40, msg.note)
     assert_equal("E4", msg.name)
     msg.note += 5
     assert_equal(0x45, msg.note)
-    assert_equal("A4", msg.name)     
+    assert_equal("A4", msg.name)
   end
 
   def test_octave
-    msg = NoteOn["E4"].new(0, 100)
+    msg = MIDIMessage::NoteOn["E4"].new(0, 100)
     assert_equal(0x40, msg.note)
     assert_equal("E4", msg.name)
     msg.octave += 1
     assert_equal(0x4C, msg.note)
-    assert_equal("E5", msg.name)     
+    assert_equal("E5", msg.name)
   end
-   
-end
+
+end

data/test/parser_test.rb

@@ -1,72 +1,67 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
+class ParserTest < Minitest::Test
 
-class ParserTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include TestHelper
-  
   def test_sysex
     msg = MIDIMessage.parse(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-    assert_equal(SystemExclusive::Command, msg.class)
-    assert_equal(SystemExclusive::Node, msg.node.class) 
+    assert_equal(MIDIMessage::SystemExclusive::Command, msg.class)
+    assert_equal(MIDIMessage::SystemExclusive::Node, msg.node.class)
     assert_equal([0x40, 0x00, 0x7F], msg.address)
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], msg.to_bytes)      
-  end        
-  
+    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], msg.to_bytes)
+  end
+
   def test_note_off
     msg = MIDIMessage.parse(0x80, 0x40, 0x40)
-    assert_equal(NoteOff, msg.class)
+    assert_equal(MIDIMessage::NoteOff, msg.class)
     assert_equal([0x80, 0x40, 0x40], msg.to_a)
   end
-  
+
   def test_note_on
     msg = MIDIMessage.parse(0x90, 0x40, 0x40)
-    assert_equal(NoteOn, msg.class)
-    assert_equal([0x90, 0x40, 0x40], msg.to_a)  
-  end  
-  
+    assert_equal(MIDIMessage::NoteOn, msg.class)
+    assert_equal([0x90, 0x40, 0x40], msg.to_a)
+  end
+
   def test_polyphonic_aftertouch
     msg = MIDIMessage.parse(0xA1, 0x40, 0x40)
-    assert_equal(PolyphonicAftertouch, msg.class)
-    assert_equal([0xA1, 0x40, 0x40], msg.to_a)      
-  end  
-  
+    assert_equal(MIDIMessage::PolyphonicAftertouch, msg.class)
+    assert_equal([0xA1, 0x40, 0x40], msg.to_a)
+  end
+
   def test_control_change
     msg = MIDIMessage.parse(0xB2, 0x20, 0x20)
-    assert_equal(ControlChange, msg.class)
-    assert_equal([0xB2, 0x20, 0x20], msg.to_a)    
+    assert_equal(MIDIMessage::ControlChange, msg.class)
+    assert_equal([0xB2, 0x20, 0x20], msg.to_a)
   end
-  
+
   def test_program_change
     msg = MIDIMessage.parse(0xC3, 0x40)
-    assert_equal(ProgramChange, msg.class)
+    assert_equal(MIDIMessage::ProgramChange, msg.class)
     assert_equal("C340", msg.to_bytestr)
   end
-  
+
   def test_channel_aftertouch
     msg = MIDIMessage.parse("D350")
-    assert_equal(ChannelAftertouch, msg.class)
-    assert_equal([0xD3, 0x50], msg.to_a)  
-  end  
-    
+    assert_equal(MIDIMessage::ChannelAftertouch, msg.class)
+    assert_equal([0xD3, 0x50], msg.to_a)
+  end
+
   def test_pitch_bend
     msg = MIDIMessage.parse("E050A0")
-    assert_equal(PitchBend, msg.class)
-    assert_equal([0xE0, 0x50, 0xA0], msg.to_a)      
-  end   
-   
+    assert_equal(MIDIMessage::PitchBend, msg.class)
+    assert_equal([0xE0, 0x50, 0xA0], msg.to_a)
+  end
+
   def test_system_common
     msg = MIDIMessage.parse([0xF1, 0x50, 0xA0])
-    assert_equal(SystemCommon, msg.class)
-    assert_equal([0xF1, 0x50, 0xA0], msg.to_a)   
-  end    
-  
+    assert_equal(MIDIMessage::SystemCommon, msg.class)
+    assert_equal([0xF1, 0x50, 0xA0], msg.to_a)
+  end
+
   def test_system_realtime
     msg = MIDIMessage.parse(0xF8)
-    assert_equal(SystemRealtime, msg.class)
-    assert_equal([0xF8], msg.to_a)     
-  end        
-   
-end
+    assert_equal(MIDIMessage::SystemRealtime, msg.class)
+    assert_equal([0xF8], msg.to_a)
+  end
+
+end

data/test/system_exclusive_test.rb

@@ -1,123 +1,118 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
+class SystemExclusiveMessageTest < Minitest::Test
 
-class SystemExclusiveMessageTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include TestHelper
- 
   def test_node
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
     assert_equal(0x41, node.manufacturer_id)
     assert_equal(0x42, node.model_id)
-    assert_equal(0x10, node.device_id)  
+    assert_equal(0x10, node.device_id)
   end
 
   def test_node_manufacturer_constant
-    node = SystemExclusive::Node.new(:Roland, :model_id => 0x42, :device_id => 0x10)
+    node = MIDIMessage::SystemExclusive::Node.new(:Roland, :model_id => 0x42, :device_id => 0x10)
     assert_equal(0x41, node.manufacturer_id)
     assert_equal(0x42, node.model_id)
-    assert_equal(0x10, node.device_id)  
+    assert_equal(0x10, node.device_id)
     assert_equal([0x41, 0x10, 0x42], node.to_a)
   end
 
   def test_no_node
-    msg = SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10)  
+    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10)
     assert_equal([0xF0, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], msg.to_bytes)
   end
-  
+
   def test_node_without_model_id
-    node = SystemExclusive::Node.new(:Roland, :device_id => 0x10)
+    node = MIDIMessage::SystemExclusive::Node.new(:Roland, :device_id => 0x10)
     assert_equal(0x41, node.manufacturer_id)
     assert_equal(nil, node.model_id)
-    assert_equal(0x10, node.device_id)  
+    assert_equal(0x10, node.device_id)
     assert_equal([0x41, 0x10], node.to_a)
-    msg = SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
-    assert_equal(10, msg.to_bytes.size)    
+    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
+    assert_equal(10, msg.to_bytes.size)
     assert_equal([0xF0, 0x41, 0x10, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], msg.to_bytes)
   end
-  
+
   def test_parse_weird_message
-    msg = SystemExclusive.new(0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
+    msg = MIDIMessage::SystemExclusive.new(0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
     assert_equal([0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41], msg.data)
-    assert_equal([0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7], msg.to_bytes) 
+    assert_equal([0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7], msg.to_bytes)
   end
-      
+
   def test_new
-    msg = SystemExclusive.new(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
+    msg = MIDIMessage::SystemExclusive.new(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
     assert_equal(0x41, msg.node.manufacturer_id)
     assert_equal(0x42, msg.node.model_id)
-    assert_equal(0x10, msg.node.device_id)  
+    assert_equal(0x10, msg.node.device_id)
     assert_equal([0x40, 0x00, 0x7F], msg.address)
-    assert_equal(0x10, msg.data)          
+    assert_equal(0x10, msg.data)
   end
-  
+
   def test_command
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
     assert_equal(node, msg.node)
     assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal(0x10, msg.data)      
-  end  
-  
+    assert_equal(0x10, msg.data)
+  end
+
   def test_request_byte_size
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10, :node => node)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10, :node => node)
     assert_equal(node, msg.node)
     assert_equal([0x40, 0x7F, 0x00], msg.address)
     assert_equal([0x0, 0x0, 0x10], msg.size)
-  end 
-  
+  end
+
   def test_request_array_size
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Request.new([0x40, 0x7F, 0x00], [0x0, 0x9, 0x10], :node => node)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], [0x0, 0x9, 0x10], :node => node)
     assert_equal(node, msg.node)
     assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal([0x0, 0x9, 0x10], msg.size)    
+    assert_equal([0x0, 0x9, 0x10], msg.size)
   end
 
   def test_request_numeric_size
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Request.new([0x40, 0x7F, 0x00], 300, :node => node)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 300, :node => node)
     assert_equal(node, msg.node)
     assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal([0x0, 0x35, 0xF7], msg.size)    
+    assert_equal([0x0, 0x35, 0xF7], msg.size)
   end
-    
+
   def test_node_oriented
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
     msg = node.request([0x40, 0x7F, 0x00], 0x10)
     assert_equal(node, msg.node)
     assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal([0x0, 0x0, 0x10], msg.size)    
+    assert_equal([0x0, 0x0, 0x10], msg.size)
   end
-  
+
   def test_prototype
-    prototype = SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10)
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    prototype = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
     msg = node.new_message_from(prototype)
     assert_equal(node, msg.node)
     assert_equal(prototype.address, msg.address)
     assert_equal(prototype.size, msg.size)
-  end        
-  
-  def test_checksum    
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
+  end
+
+  def test_checksum
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
     assert_equal(0x41, msg.checksum)
   end
-  
+
   def test_to_a
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
     assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], msg.to_bytes)
   end
-  
+
   def test_to_s
-    node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    msg = SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
+    node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
     assert_equal("F04110421240007F0041F7", msg.to_bytestr)
   end
-   
-end
+
+end