midi-message 0.4.8 → 0.4.9

data/test/message_test.rb

@@ -1,139 +1,45 @@
 require "helper"
 
-class ShortMessageTest < Minitest::Test
+class MIDIMessage::MessageTest < Minitest::Test
 
-  def test_channel_message
-    message = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
-    refute_nil message
-    assert message.kind_of?(MIDIMessage)
-    assert_equal(0x9, message.status[0])
-    assert_equal(0x0, message.status[1])
-    assert_equal(0x40, message.data[0])
-    assert_equal(0x40, message.data[1])
-    assert_equal([0x90, 0x40, 0x40], message.to_a)
-    assert_equal("904040", message.to_bytestr)
-  end
-
-  def test_to_type
-    message = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
-    typemessage = message.to_type
-    assert_equal(MIDIMessage::NoteOn, typemessage.class)
-    assert_equal(message.status[1], typemessage.channel)
-    assert_equal(message.data[0], typemessage.note)
-    assert_equal(message.data[1], typemessage.velocity)
-    assert_equal(message.to_a, typemessage.to_a)
-    assert_equal(message.to_bytestr, typemessage.to_bytestr)
-  end
-
-  def test_note_off
-    message = MIDIMessage::NoteOff.new(0, 0x40, 0x40)
-    assert_equal(0, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-    assert_equal([0x80, 0x40, 0x40], message.to_a)
-    assert_equal("804040", message.to_bytestr)
-  end
-
-  def test_note_on
-    message = MIDIMessage::NoteOn.new(1, 0x40, 0x40)
-    assert_equal(1, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-    assert_equal([0x91, 0x40, 0x40], message.to_a)
-    assert_equal("914040", message.to_bytestr)
-    assert_equal([0x91, 0x40, 0x40], message.to_bytes)
-  end
-
-  def test_change_channel
-    message = MIDIMessage::NoteOn.new(1, 0x40, 0x40)
-    assert_equal(1, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-    assert_equal([0x91, 0x40, 0x40], message.to_a)
-    assert_equal("914040", message.to_bytestr)
-    assert_equal([0x91, 0x40, 0x40], message.to_bytes)
+  context "Message" do
 
-    message.channel = 3
-    assert_equal(3, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-    assert_equal([0x93, 0x40, 0x40], message.to_a)
-    assert_equal("934040", message.to_bytestr)
-    assert_equal([0x93, 0x40, 0x40], message.to_bytes)
-  end
+    context "#update" do
 
-  def test_note_on_to_note_off
-    message = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
-    assert_equal(0, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)
-    assert_equal([0x90, 0x40, 0x40], message.to_a)
-    off = message.to_note_off
-    assert_equal(0, off.channel)
-    assert_equal(0x40, off.note)
-    assert_equal(0x40, off.velocity)
-    assert_equal([0x80, 0x40, 0x40], off.to_a)
-  end
+      context "note" do
 
+        setup do
+          @message = MIDIMessage::NoteOn["E4"].new(0, 100)
+          assert_equal(0x40, @message.note)
+          assert_equal("E4", @message.name)
+        end
 
-  def test_polyphonic_aftertouch
-    message = MIDIMessage::PolyphonicAftertouch.new(1, 0x40, 0x40)
-    assert_equal(1, message.channel)
-    assert_equal(0x40, message.note)
-    assert_equal(0x40, message.value)
-    assert_equal([0xA1, 0x40, 0x40], message.to_a)
-    assert_equal("A14040", message.to_bytestr)
-  end
+        should "be mutable" do
+          @message.note += 5
+          assert_equal(0x45, @message.note)
+          assert_equal("A4", @message.name)
+        end
 
-  def test_control_change
-    message = MIDIMessage::ControlChange.new(2, 0x20, 0x20)
-    assert_equal(message.channel, 2)
-    assert_equal(0x20, message.index)
-    assert_equal(0x20, message.value)
-    assert_equal([0xB2, 0x20, 0x20], message.to_a)
-    assert_equal("B22020", message.to_bytestr)
-  end
+      end
 
-  def test_program_change
-    message = MIDIMessage::ProgramChange.new(3, 0x40)
-    assert_equal(3, message.channel)
-    assert_equal(0x40, message.program)
-    assert_equal([0xC3, 0x40], message.to_a)
-    assert_equal("C340", message.to_bytestr)
+      context "octave" do
 
-  end
+        setup do
+          @message = MIDIMessage::NoteOn["E4"].new(0, 100)
+          assert_equal(0x40, @message.note)
+          assert_equal("E4", @message.name)
+        end
 
-  def test_channel_aftertouch
-    message = MIDIMessage::ChannelAftertouch.new(3, 0x50)
-    assert_equal(3, message.channel)
-    assert_equal(0x50, message.value)
-    assert_equal([0xD3, 0x50], message.to_a)
-    assert_equal("D350", message.to_bytestr)
-  end
+        should "be mutable" do
+          @message.octave += 1
+          assert_equal(0x4C, @message.note)
+          assert_equal("E5", @message.name)
+        end
 
-  def test_pitch_bend
-    message = MIDIMessage::PitchBend.new(0, 0x50, 0xA0)
-    assert_equal(0, message.channel)
-    assert_equal(0x50, message.low)
-    assert_equal(0xA0, message.high)
-    assert_equal([0xE0, 0x50, 0xA0], message.to_a)
-    assert_equal("E050A0", message.to_bytestr)
-  end
+      end
 
-  def test_system_common
-    message = MIDIMessage::SystemCommon.new(1, 0x50, 0xA0)
-    assert_equal(1, message.status[1])
-    assert_equal(0x50, message.data[0])
-    assert_equal(0xA0, message.data[1])
-    assert_equal([0xF1, 0x50, 0xA0], message.to_a)
-    assert_equal("F150A0", message.to_bytestr)
-  end
+    end
 
-  def test_system_realtime
-    message = MIDIMessage::SystemRealtime.new(0x8)
-    assert_equal(8, message.id)
-    assert_equal([0xF8], message.to_a)
-    assert_equal("F8", message.to_bytestr)
   end
 
 end

data/test/messages_test.rb

@@ -0,0 +1,139 @@
+require "helper"
+
+class MIDIMessage::MessagesTest < Minitest::Test
+
+  def test_channel_message
+    message = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
+    refute_nil message
+    assert message.kind_of?(MIDIMessage)
+    assert_equal(0x9, message.status[0])
+    assert_equal(0x0, message.status[1])
+    assert_equal(0x40, message.data[0])
+    assert_equal(0x40, message.data[1])
+    assert_equal([0x90, 0x40, 0x40], message.to_a)
+    assert_equal("904040", message.to_bytestr)
+  end
+
+  def test_to_type
+    message = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
+    typemessage = message.to_type
+    assert_equal(MIDIMessage::NoteOn, typemessage.class)
+    assert_equal(message.status[1], typemessage.channel)
+    assert_equal(message.data[0], typemessage.note)
+    assert_equal(message.data[1], typemessage.velocity)
+    assert_equal(message.to_a, typemessage.to_a)
+    assert_equal(message.to_bytestr, typemessage.to_bytestr)
+  end
+
+  def test_note_off
+    message = MIDIMessage::NoteOff.new(0, 0x40, 0x40)
+    assert_equal(0, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)
+    assert_equal([0x80, 0x40, 0x40], message.to_a)
+    assert_equal("804040", message.to_bytestr)
+  end
+
+  def test_note_on
+    message = MIDIMessage::NoteOn.new(1, 0x40, 0x40)
+    assert_equal(1, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)
+    assert_equal([0x91, 0x40, 0x40], message.to_a)
+    assert_equal("914040", message.to_bytestr)
+    assert_equal([0x91, 0x40, 0x40], message.to_bytes)
+  end
+
+  def test_change_channel
+    message = MIDIMessage::NoteOn.new(1, 0x40, 0x40)
+    assert_equal(1, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)
+    assert_equal([0x91, 0x40, 0x40], message.to_a)
+    assert_equal("914040", message.to_bytestr)
+    assert_equal([0x91, 0x40, 0x40], message.to_bytes)
+
+    message.channel = 3
+    assert_equal(3, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)
+    assert_equal([0x93, 0x40, 0x40], message.to_a)
+    assert_equal("934040", message.to_bytestr)
+    assert_equal([0x93, 0x40, 0x40], message.to_bytes)
+  end
+
+  def test_note_on_to_note_off
+    message = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
+    assert_equal(0, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.velocity)
+    assert_equal([0x90, 0x40, 0x40], message.to_a)
+    off = message.to_note_off
+    assert_equal(0, off.channel)
+    assert_equal(0x40, off.note)
+    assert_equal(0x40, off.velocity)
+    assert_equal([0x80, 0x40, 0x40], off.to_a)
+  end
+
+
+  def test_polyphonic_aftertouch
+    message = MIDIMessage::PolyphonicAftertouch.new(1, 0x40, 0x40)
+    assert_equal(1, message.channel)
+    assert_equal(0x40, message.note)
+    assert_equal(0x40, message.value)
+    assert_equal([0xA1, 0x40, 0x40], message.to_a)
+    assert_equal("A14040", message.to_bytestr)
+  end
+
+  def test_control_change
+    message = MIDIMessage::ControlChange.new(2, 0x20, 0x20)
+    assert_equal(message.channel, 2)
+    assert_equal(0x20, message.index)
+    assert_equal(0x20, message.value)
+    assert_equal([0xB2, 0x20, 0x20], message.to_a)
+    assert_equal("B22020", message.to_bytestr)
+  end
+
+  def test_program_change
+    message = MIDIMessage::ProgramChange.new(3, 0x40)
+    assert_equal(3, message.channel)
+    assert_equal(0x40, message.program)
+    assert_equal([0xC3, 0x40], message.to_a)
+    assert_equal("C340", message.to_bytestr)
+
+  end
+
+  def test_channel_aftertouch
+    message = MIDIMessage::ChannelAftertouch.new(3, 0x50)
+    assert_equal(3, message.channel)
+    assert_equal(0x50, message.value)
+    assert_equal([0xD3, 0x50], message.to_a)
+    assert_equal("D350", message.to_bytestr)
+  end
+
+  def test_pitch_bend
+    message = MIDIMessage::PitchBend.new(0, 0x50, 0xA0)
+    assert_equal(0, message.channel)
+    assert_equal(0x50, message.low)
+    assert_equal(0xA0, message.high)
+    assert_equal([0xE0, 0x50, 0xA0], message.to_a)
+    assert_equal("E050A0", message.to_bytestr)
+  end
+
+  def test_system_common
+    message = MIDIMessage::SystemCommon.new(1, 0x50, 0xA0)
+    assert_equal(1, message.status[1])
+    assert_equal(0x50, message.data[0])
+    assert_equal(0xA0, message.data[1])
+    assert_equal([0xF1, 0x50, 0xA0], message.to_a)
+    assert_equal("F150A0", message.to_bytestr)
+  end
+
+  def test_system_realtime
+    message = MIDIMessage::SystemRealtime.new(0x8)
+    assert_equal(8, message.id)
+    assert_equal([0xF8], message.to_a)
+    assert_equal("F8", message.to_bytestr)
+  end
+
+end

data/test/parser_test.rb

@@ -1,6 +1,6 @@
 require "helper"
 
-class ParserTest < Minitest::Test
+class MIDIMessage::ParserTest < Minitest::Test
 
   def test_sysex
     msg = MIDIMessage.parse(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)

data/test/system_exclusive_test.rb

@@ -1,118 +1,265 @@
 require "helper"
 
-class SystemExclusiveMessageTest < Minitest::Test
+class MIDIMessage::SystemExclusiveTest < Minitest::Test
 
-  def test_node
-    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)
-  end
+  context "SystemExclusive" do
 
-  def test_node_manufacturer_constant
-    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([0x41, 0x10, 0x42], node.to_a)
-  end
+    context "Node" do
 
-  def test_no_node
-    msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10)
-    assert_equal([0xF0, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], msg.to_bytes)
-  end
+      context "#initialize" do
 
-  def test_node_without_model_id
-    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([0x41, 0x10], node.to_a)
-    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
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+        end
 
-  def test_parse_weird_message
-    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)
-  end
+        should "populate message" do
+          assert_equal(0x41, @node.manufacturer_id)
+          assert_equal(0x42, @node.model_id)
+          assert_equal(0x10, @node.device_id)
+        end
 
-  def test_new
-    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([0x40, 0x00, 0x7F], msg.address)
-    assert_equal(0x10, msg.data)
-  end
+      end
 
-  def test_command
-    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
+      context "#request" do
 
-  def test_request_byte_size
-    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
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+          @message = @node.request([0x40, 0x7F, 0x00], 0x10)
+        end
 
-  def test_request_array_size
-    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)
-  end
+        should "build correct request message object" do
+          assert_equal(@node, @message.node)
+          assert_equal([0x40, 0x7F, 0x00], @message.address)
+          assert_equal([0x0, 0x0, 0x10], @message.size)
+        end
 
-  def test_request_numeric_size
-    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)
-  end
+      end
 
-  def test_node_oriented
-    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)
-  end
+      context "#manufacturer_id" do
 
-  def test_prototype
-    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
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(:Roland, :model_id => 0x42, :device_id => 0x10)
+        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
+        should "populate manufacturer id from constant" do
+          assert_equal(0x41, @node.manufacturer_id)
+          assert_equal(0x42, @node.model_id)
+          assert_equal(0x10, @node.device_id)
+          assert_equal([0x41, 0x10, 0x42], @node.to_a)
+        end
 
-  def test_to_a
-    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
+      end
+
+      context "#model_id" do
+
+        context "nil" do
+
+          setup do
+            @node = MIDIMessage::SystemExclusive::Node.new(:Roland, :device_id => 0x10)
+            @message = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => @node)
+          end
+
+          should "create node with nil model_id" do
+            assert_equal(0x41, @node.manufacturer_id)
+            assert_equal(nil, @node.model_id)
+            assert_equal(0x10, @node.device_id)
+            assert_equal([0x41, 0x10], @node.to_a)
+          end
+
+          should "associate node with message" do
+            assert_equal(10, @message.to_bytes.size)
+            assert_equal([0xF0, 0x41, 0x10, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], @message.to_bytes)
+          end
+
+        end
+
+      end
+
+      context "#new_message_from" do
+
+        setup do
+          @prototype = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10)
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+          @message = @node.new_message_from(@prototype)
+        end
+
+        should "create clone of original request" do
+          refute_nil(@message)
+          refute_equal(@prototype, @message)
+          assert_equal(@node, @message.node)
+          assert_equal(@prototype.address, @message.address)
+          assert_equal(@prototype.size, @message.size)
+        end
+
+      end
+
+    end
+
+    context "Command" do
+
+      context "#initialize" do
+
+        context "with node" do
+
+          setup do
+            @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+            @message = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => @node)
+          end
+
+          should "create message and associate with node" do
+            assert_equal(@node, @message.node)
+            assert_equal([0x40, 0x7F, 0x00], @message.address)
+            assert_equal(0x10, @message.data)
+          end
+
+        end
+
+        context "without node" do
+
+          setup do
+            @message = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10)
+          end
+
+          should "populate message" do
+            assert_equal([0xF0, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], @message.to_bytes)
+          end
+
+        end
+
+      end
+
+      context "#checksum" do
+
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+          @message = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => @node)
+        end
+
+        should "have correct checksum" do
+          assert_equal(0x41, @message.checksum)
+        end
+
+      end
+
+      context "#to_a" do
+
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+          @message = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => @node)
+        end
+
+        should "have correct data in bytes" do
+          assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], @message.to_bytes)
+        end
+
+      end
+
+      context "#to_s" do
+
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+          @message = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => @node)
+        end
+
+        should "have correct data as hex string" do
+          assert_equal("F04110421240007F0041F7", @message.to_bytestr)
+        end
+
+      end
+
+    end
+
+    context "Request" do
+
+      context "#size" do
+
+        setup do
+          @node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
+        end
+
+        context "array" do
+
+          setup do
+            @message = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], [0x0, 0x9, 0x10], :node => @node)
+          end
+
+          should "should have correct size data" do
+            assert_equal(@node, @message.node)
+            assert_equal([0x40, 0x7F, 0x00], @message.address)
+            assert_equal([0x0, 0x9, 0x10], @message.size)
+          end
+
+        end
+
+        context "byte" do
+
+          setup do
+            @message = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10, :node => @node)
+          end
+
+          should "should have correct size data" do
+            assert_equal(@node, @message.node)
+            assert_equal([0x40, 0x7F, 0x00], @message.address)
+            assert_equal([0x0, 0x0, 0x10], @message.size)
+          end
+
+        end
+
+        context "numeric" do
+
+          setup do
+            @message = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 300, :node => @node)
+          end
+
+          should "should have correct size data" do
+            assert_equal(@node, @message.node)
+            assert_equal([0x40, 0x7F, 0x00], @message.address)
+            assert_equal([0x0, 0x35, 0xF7], @message.size)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "Builder" do
+
+      context ".build" do
+
+        context "normal message" do
+
+          setup do
+            @message = MIDIMessage::SystemExclusive::Builder.build(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
+          end
+
+          should "create message" do
+            assert_equal(0x41, @message.node.manufacturer_id)
+            assert_equal(0x42, @message.node.model_id)
+            assert_equal(0x10, @message.node.device_id)
+            assert_equal([0x40, 0x00, 0x7F], @message.address)
+            assert_equal(0x10, @message.data)
+          end
+
+        end
+
+        context "weird message" do
+
+          setup do
+            @message = MIDIMessage::SystemExclusive::Builder.build(0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
+          end
+
+          should "create message" do
+            assert_equal([0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41], @message.data)
+            assert_equal([0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7], @message.to_bytes)
+          end
+
+        end
+
+      end
+
+    end
 
-  def test_to_s
-    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