midi-message 0.4.4 → 0.4.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4,7 +4,7 @@ module MIDIMessage
4
4
  module SystemMessage
5
5
 
6
6
  def self.included(base)
7
- base.send(:include, ShortMessage)
7
+ base.send(:include, Message)
8
8
  end
9
9
 
10
10
  # In the case of something like SystemCommon.new(0xF2, 0x00, 0x08), the first nibble F is redundant because
@@ -17,5 +17,5 @@ module MIDIMessage
17
17
  end
18
18
 
19
19
  end
20
-
20
+
21
21
  end
@@ -1,48 +1,43 @@
1
- #!/usr/bin/env ruby
1
+ require "helper"
2
2
 
3
- require 'helper'
3
+ class ConstantsTest < Minitest::Test
4
4
 
5
- class ConstantsTest < Test::Unit::TestCase
6
-
7
- include MIDIMessage
8
- include TestHelper
9
-
10
5
  def test_note_on
11
- msg = NoteOn["c3"].new(0, 100)
12
- assert_equal(NoteOn, msg.class)
6
+ msg = MIDIMessage::NoteOn["c3"].new(0, 100)
7
+ assert_equal(MIDIMessage::NoteOn, msg.class)
13
8
  assert_equal("C3", msg.name)
14
9
  assert_equal("C", msg.note_name)
15
- assert_equal([0x90, 0x30, 100], msg.to_a)
16
- end
17
-
10
+ assert_equal([0x90, 0x30, 100], msg.to_a)
11
+ end
12
+
18
13
  def test_control_change
19
- msg = NoteOn["C3"].new(0, 100)
20
- assert_equal(NoteOn, msg.class)
14
+ msg = MIDIMessage::NoteOn["C3"].new(0, 100)
15
+ assert_equal(MIDIMessage::NoteOn, msg.class)
21
16
  assert_equal("C3", msg.name)
22
- assert_equal([0x90, 0x30, 100], msg.to_a)
17
+ assert_equal([0x90, 0x30, 100], msg.to_a)
23
18
  end
24
-
19
+
25
20
  def test_control_change
26
- msg = ControlChange["Modulation Wheel"].new(2, 0x20)
27
- assert_equal(ControlChange, msg.class)
21
+ msg = MIDIMessage::ControlChange["Modulation Wheel"].new(2, 0x20)
22
+ assert_equal(MIDIMessage::ControlChange, msg.class)
28
23
  assert_equal(msg.channel, 2)
29
24
  assert_equal(0x01, msg.index)
30
25
  assert_equal(0x20, msg.value)
31
- assert_equal([0xB2, 0x01, 0x20], msg.to_a)
26
+ assert_equal([0xB2, 0x01, 0x20], msg.to_a)
32
27
  end
33
28
 
34
29
  def test_system_realtime
35
- msg = SystemRealtime["Stop"].new
36
- assert_equal(SystemRealtime, msg.class)
30
+ msg = MIDIMessage::SystemRealtime["Stop"].new
31
+ assert_equal(MIDIMessage::SystemRealtime, msg.class)
37
32
  assert_equal("Stop", msg.name)
38
- assert_equal([0xFC], msg.to_a)
39
- end
40
-
33
+ assert_equal([0xFC], msg.to_a)
34
+ end
35
+
41
36
  def test_system_common
42
- msg = SystemCommon["Song Select"].new
43
- assert_equal(SystemCommon, msg.class)
37
+ msg = MIDIMessage::SystemCommon["Song Select"].new
38
+ assert_equal(MIDIMessage::SystemCommon, msg.class)
44
39
  assert_equal("Song Select", msg.name)
45
- assert_equal([0xF3], msg.to_a)
46
- end
47
-
48
- end
40
+ assert_equal([0xF3], msg.to_a)
41
+ end
42
+
43
+ end
data/test/context_test.rb CHANGED
@@ -1,10 +1,6 @@
1
- #!/usr/bin/env ruby
1
+ require "helper"
2
2
 
3
- require 'helper'
4
-
5
- class ContextTest < Test::Unit::TestCase
6
-
7
- include TestHelper
3
+ class ContextTest < Minitest::Test
8
4
 
9
5
  def test_note_off
10
6
  msg = MIDIMessage.with(:channel => 0, :velocity => 64) do
data/test/helper.rb CHANGED
@@ -1,11 +1,6 @@
1
- #!/usr/bin/env ruby
2
-
3
1
  dir = File.dirname(File.expand_path(__FILE__))
4
- $LOAD_PATH.unshift dir + '/../lib'
2
+ $LOAD_PATH.unshift dir + "/../lib"
5
3
 
6
- require 'test/unit'
7
- require 'midi-message'
4
+ require "minitest/autorun"
8
5
 
9
- module TestHelper
10
-
11
- end
6
+ require "midi-message"
@@ -1,53 +1,48 @@
1
- #!/usr/bin/env ruby
1
+ require "helper"
2
2
 
3
- require 'helper'
4
-
5
- class ShortMessageTest < Test::Unit::TestCase
6
-
7
- include MIDIMessage
8
- include TestHelper
3
+ class ShortMessageTest < Minitest::Test
9
4
 
10
5
  def test_channel_message
11
- msg = ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
6
+ msg = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
12
7
  assert_equal(0x9, msg.status[0])
13
8
  assert_equal(0x0, msg.status[1])
14
9
  assert_equal(0x40, msg.data[0])
15
10
  assert_equal(0x40, msg.data[1])
16
11
  assert_equal([0x90, 0x40, 0x40], msg.to_a)
17
- assert_equal("904040", msg.to_bytestr)
12
+ assert_equal("904040", msg.to_bytestr)
18
13
  end
19
-
14
+
20
15
  def test_to_type
21
- msg = ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
16
+ msg = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
22
17
  typemsg = msg.to_type
23
- assert_equal(NoteOn, typemsg.class)
18
+ assert_equal(MIDIMessage::NoteOn, typemsg.class)
24
19
  assert_equal(msg.status[1], typemsg.channel)
25
20
  assert_equal(msg.data[0], typemsg.note)
26
21
  assert_equal(msg.data[1], typemsg.velocity)
27
22
  assert_equal(msg.to_a, typemsg.to_a)
28
- assert_equal(msg.to_bytestr, typemsg.to_bytestr)
23
+ assert_equal(msg.to_bytestr, typemsg.to_bytestr)
29
24
  end
30
-
25
+
31
26
  def test_note_off
32
- msg = NoteOff.new(0, 0x40, 0x40)
27
+ msg = MIDIMessage::NoteOff.new(0, 0x40, 0x40)
33
28
  assert_equal(0, msg.channel)
34
29
  assert_equal(0x40, msg.note)
35
30
  assert_equal(0x40, msg.velocity)
36
31
  assert_equal([0x80, 0x40, 0x40], msg.to_a)
37
32
  assert_equal("804040", msg.to_bytestr)
38
33
  end
39
-
34
+
40
35
  def test_note_on
41
- msg = NoteOn.new(0, 0x40, 0x40)
36
+ msg = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
42
37
  assert_equal(0, msg.channel)
43
38
  assert_equal(0x40, msg.note)
44
39
  assert_equal(0x40, msg.velocity)
45
40
  assert_equal([0x90, 0x40, 0x40], msg.to_a)
46
- assert_equal("904040", msg.to_bytestr)
41
+ assert_equal("904040", msg.to_bytestr)
47
42
  end
48
-
43
+
49
44
  def test_note_on_to_note_off
50
- msg = NoteOn.new(0, 0x40, 0x40)
45
+ msg = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
51
46
  assert_equal(0, msg.channel)
52
47
  assert_equal(0x40, msg.note)
53
48
  assert_equal(0x40, msg.velocity)
@@ -56,68 +51,68 @@ class ShortMessageTest < Test::Unit::TestCase
56
51
  assert_equal(0, off.channel)
57
52
  assert_equal(0x40, off.note)
58
53
  assert_equal(0x40, off.velocity)
59
- assert_equal([0x80, 0x40, 0x40], off.to_a)
60
- end
61
-
62
-
54
+ assert_equal([0x80, 0x40, 0x40], off.to_a)
55
+ end
56
+
57
+
63
58
  def test_polyphonic_aftertouch
64
- msg = PolyphonicAftertouch.new(1, 0x40, 0x40)
59
+ msg = MIDIMessage::PolyphonicAftertouch.new(1, 0x40, 0x40)
65
60
  assert_equal(1, msg.channel)
66
61
  assert_equal(0x40, msg.note)
67
62
  assert_equal(0x40, msg.value)
68
63
  assert_equal([0xA1, 0x40, 0x40], msg.to_a)
69
- assert_equal("A14040", msg.to_bytestr)
70
- end
71
-
64
+ assert_equal("A14040", msg.to_bytestr)
65
+ end
66
+
72
67
  def test_control_change
73
- msg = ControlChange.new(2, 0x20, 0x20)
68
+ msg = MIDIMessage::ControlChange.new(2, 0x20, 0x20)
74
69
  assert_equal(msg.channel, 2)
75
70
  assert_equal(0x20, msg.index)
76
71
  assert_equal(0x20, msg.value)
77
72
  assert_equal([0xB2, 0x20, 0x20], msg.to_a)
78
- assert_equal("B22020", msg.to_bytestr)
73
+ assert_equal("B22020", msg.to_bytestr)
79
74
  end
80
-
75
+
81
76
  def test_program_change
82
- msg = ProgramChange.new(3, 0x40)
77
+ msg = MIDIMessage::ProgramChange.new(3, 0x40)
83
78
  assert_equal(3, msg.channel)
84
79
  assert_equal(0x40, msg.program)
85
80
  assert_equal([0xC3, 0x40], msg.to_a)
86
81
  assert_equal("C340", msg.to_bytestr)
87
-
82
+
88
83
  end
89
-
84
+
90
85
  def test_channel_aftertouch
91
- msg = ChannelAftertouch.new(3, 0x50)
86
+ msg = MIDIMessage::ChannelAftertouch.new(3, 0x50)
92
87
  assert_equal(3, msg.channel)
93
88
  assert_equal(0x50, msg.value)
94
89
  assert_equal([0xD3, 0x50], msg.to_a)
95
- assert_equal("D350", msg.to_bytestr)
96
- end
97
-
90
+ assert_equal("D350", msg.to_bytestr)
91
+ end
92
+
98
93
  def test_pitch_bend
99
94
  msg = MIDIMessage::PitchBend.new(0, 0x50, 0xA0)
100
95
  assert_equal(0, msg.channel)
101
96
  assert_equal(0x50, msg.low)
102
97
  assert_equal(0xA0, msg.high)
103
98
  assert_equal([0xE0, 0x50, 0xA0], msg.to_a)
104
- assert_equal("E050A0", msg.to_bytestr)
105
- end
106
-
99
+ assert_equal("E050A0", msg.to_bytestr)
100
+ end
101
+
107
102
  def test_system_common
108
- msg = SystemCommon.new(1, 0x50, 0xA0)
103
+ msg = MIDIMessage::SystemCommon.new(1, 0x50, 0xA0)
109
104
  assert_equal(1, msg.status[1])
110
105
  assert_equal(0x50, msg.data[0])
111
106
  assert_equal(0xA0, msg.data[1])
112
107
  assert_equal([0xF1, 0x50, 0xA0], msg.to_a)
113
- assert_equal("F150A0", msg.to_bytestr)
114
- end
115
-
108
+ assert_equal("F150A0", msg.to_bytestr)
109
+ end
110
+
116
111
  def test_system_realtime
117
- msg = SystemRealtime.new(0x8)
112
+ msg = MIDIMessage::SystemRealtime.new(0x8)
118
113
  assert_equal(8, msg.id)
119
114
  assert_equal([0xF8], msg.to_a)
120
- assert_equal("F8", msg.to_bytestr)
121
- end
122
-
115
+ assert_equal("F8", msg.to_bytestr)
116
+ end
117
+
123
118
  end
@@ -1,28 +1,23 @@
1
- #!/usr/bin/env ruby
1
+ require "helper"
2
2
 
3
- require 'helper'
3
+ class MutabilityTest < Minitest::Test
4
4
 
5
- class MutabilityTest < Test::Unit::TestCase
6
-
7
- include MIDIMessage
8
- include TestHelper
9
-
10
5
  def test_note
11
- msg = NoteOn["E4"].new(0, 100)
6
+ msg = MIDIMessage::NoteOn["E4"].new(0, 100)
12
7
  assert_equal(0x40, msg.note)
13
8
  assert_equal("E4", msg.name)
14
9
  msg.note += 5
15
10
  assert_equal(0x45, msg.note)
16
- assert_equal("A4", msg.name)
11
+ assert_equal("A4", msg.name)
17
12
  end
18
13
 
19
14
  def test_octave
20
- msg = NoteOn["E4"].new(0, 100)
15
+ msg = MIDIMessage::NoteOn["E4"].new(0, 100)
21
16
  assert_equal(0x40, msg.note)
22
17
  assert_equal("E4", msg.name)
23
18
  msg.octave += 1
24
19
  assert_equal(0x4C, msg.note)
25
- assert_equal("E5", msg.name)
20
+ assert_equal("E5", msg.name)
26
21
  end
27
-
28
- end
22
+
23
+ end
data/test/parser_test.rb CHANGED
@@ -1,72 +1,67 @@
1
- #!/usr/bin/env ruby
1
+ require "helper"
2
2
 
3
- require 'helper'
3
+ class ParserTest < Minitest::Test
4
4
 
5
- class ParserTest < Test::Unit::TestCase
6
-
7
- include MIDIMessage
8
- include TestHelper
9
-
10
5
  def test_sysex
11
6
  msg = MIDIMessage.parse(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
12
- assert_equal(SystemExclusive::Command, msg.class)
13
- assert_equal(SystemExclusive::Node, msg.node.class)
7
+ assert_equal(MIDIMessage::SystemExclusive::Command, msg.class)
8
+ assert_equal(MIDIMessage::SystemExclusive::Node, msg.node.class)
14
9
  assert_equal([0x40, 0x00, 0x7F], msg.address)
15
- assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], msg.to_bytes)
16
- end
17
-
10
+ assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], msg.to_bytes)
11
+ end
12
+
18
13
  def test_note_off
19
14
  msg = MIDIMessage.parse(0x80, 0x40, 0x40)
20
- assert_equal(NoteOff, msg.class)
15
+ assert_equal(MIDIMessage::NoteOff, msg.class)
21
16
  assert_equal([0x80, 0x40, 0x40], msg.to_a)
22
17
  end
23
-
18
+
24
19
  def test_note_on
25
20
  msg = MIDIMessage.parse(0x90, 0x40, 0x40)
26
- assert_equal(NoteOn, msg.class)
27
- assert_equal([0x90, 0x40, 0x40], msg.to_a)
28
- end
29
-
21
+ assert_equal(MIDIMessage::NoteOn, msg.class)
22
+ assert_equal([0x90, 0x40, 0x40], msg.to_a)
23
+ end
24
+
30
25
  def test_polyphonic_aftertouch
31
26
  msg = MIDIMessage.parse(0xA1, 0x40, 0x40)
32
- assert_equal(PolyphonicAftertouch, msg.class)
33
- assert_equal([0xA1, 0x40, 0x40], msg.to_a)
34
- end
35
-
27
+ assert_equal(MIDIMessage::PolyphonicAftertouch, msg.class)
28
+ assert_equal([0xA1, 0x40, 0x40], msg.to_a)
29
+ end
30
+
36
31
  def test_control_change
37
32
  msg = MIDIMessage.parse(0xB2, 0x20, 0x20)
38
- assert_equal(ControlChange, msg.class)
39
- assert_equal([0xB2, 0x20, 0x20], msg.to_a)
33
+ assert_equal(MIDIMessage::ControlChange, msg.class)
34
+ assert_equal([0xB2, 0x20, 0x20], msg.to_a)
40
35
  end
41
-
36
+
42
37
  def test_program_change
43
38
  msg = MIDIMessage.parse(0xC3, 0x40)
44
- assert_equal(ProgramChange, msg.class)
39
+ assert_equal(MIDIMessage::ProgramChange, msg.class)
45
40
  assert_equal("C340", msg.to_bytestr)
46
41
  end
47
-
42
+
48
43
  def test_channel_aftertouch
49
44
  msg = MIDIMessage.parse("D350")
50
- assert_equal(ChannelAftertouch, msg.class)
51
- assert_equal([0xD3, 0x50], msg.to_a)
52
- end
53
-
45
+ assert_equal(MIDIMessage::ChannelAftertouch, msg.class)
46
+ assert_equal([0xD3, 0x50], msg.to_a)
47
+ end
48
+
54
49
  def test_pitch_bend
55
50
  msg = MIDIMessage.parse("E050A0")
56
- assert_equal(PitchBend, msg.class)
57
- assert_equal([0xE0, 0x50, 0xA0], msg.to_a)
58
- end
59
-
51
+ assert_equal(MIDIMessage::PitchBend, msg.class)
52
+ assert_equal([0xE0, 0x50, 0xA0], msg.to_a)
53
+ end
54
+
60
55
  def test_system_common
61
56
  msg = MIDIMessage.parse([0xF1, 0x50, 0xA0])
62
- assert_equal(SystemCommon, msg.class)
63
- assert_equal([0xF1, 0x50, 0xA0], msg.to_a)
64
- end
65
-
57
+ assert_equal(MIDIMessage::SystemCommon, msg.class)
58
+ assert_equal([0xF1, 0x50, 0xA0], msg.to_a)
59
+ end
60
+
66
61
  def test_system_realtime
67
62
  msg = MIDIMessage.parse(0xF8)
68
- assert_equal(SystemRealtime, msg.class)
69
- assert_equal([0xF8], msg.to_a)
70
- end
71
-
72
- end
63
+ assert_equal(MIDIMessage::SystemRealtime, msg.class)
64
+ assert_equal([0xF8], msg.to_a)
65
+ end
66
+
67
+ end
@@ -1,123 +1,118 @@
1
- #!/usr/bin/env ruby
1
+ require "helper"
2
2
 
3
- require 'helper'
3
+ class SystemExclusiveMessageTest < Minitest::Test
4
4
 
5
- class SystemExclusiveMessageTest < Test::Unit::TestCase
6
-
7
- include MIDIMessage
8
- include TestHelper
9
-
10
5
  def test_node
11
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
6
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
12
7
  assert_equal(0x41, node.manufacturer_id)
13
8
  assert_equal(0x42, node.model_id)
14
- assert_equal(0x10, node.device_id)
9
+ assert_equal(0x10, node.device_id)
15
10
  end
16
11
 
17
12
  def test_node_manufacturer_constant
18
- node = SystemExclusive::Node.new(:Roland, :model_id => 0x42, :device_id => 0x10)
13
+ node = MIDIMessage::SystemExclusive::Node.new(:Roland, :model_id => 0x42, :device_id => 0x10)
19
14
  assert_equal(0x41, node.manufacturer_id)
20
15
  assert_equal(0x42, node.model_id)
21
- assert_equal(0x10, node.device_id)
16
+ assert_equal(0x10, node.device_id)
22
17
  assert_equal([0x41, 0x10, 0x42], node.to_a)
23
18
  end
24
19
 
25
20
  def test_no_node
26
- msg = SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10)
21
+ msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10)
27
22
  assert_equal([0xF0, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], msg.to_bytes)
28
23
  end
29
-
24
+
30
25
  def test_node_without_model_id
31
- node = SystemExclusive::Node.new(:Roland, :device_id => 0x10)
26
+ node = MIDIMessage::SystemExclusive::Node.new(:Roland, :device_id => 0x10)
32
27
  assert_equal(0x41, node.manufacturer_id)
33
28
  assert_equal(nil, node.model_id)
34
- assert_equal(0x10, node.device_id)
29
+ assert_equal(0x10, node.device_id)
35
30
  assert_equal([0x41, 0x10], node.to_a)
36
- msg = SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
37
- assert_equal(10, msg.to_bytes.size)
31
+ msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
32
+ assert_equal(10, msg.to_bytes.size)
38
33
  assert_equal([0xF0, 0x41, 0x10, 0x12, 0x40, 0x7F, 0x00, 0x10, 0x31, 0xF7], msg.to_bytes)
39
34
  end
40
-
35
+
41
36
  def test_parse_weird_message
42
- msg = SystemExclusive.new(0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
37
+ msg = MIDIMessage::SystemExclusive.new(0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
43
38
  assert_equal([0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41], msg.data)
44
- assert_equal([0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7], msg.to_bytes)
39
+ assert_equal([0xF0, 0x41, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7], msg.to_bytes)
45
40
  end
46
-
41
+
47
42
  def test_new
48
- msg = SystemExclusive.new(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
43
+ msg = MIDIMessage::SystemExclusive.new(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x10, 0x41, 0xF7)
49
44
  assert_equal(0x41, msg.node.manufacturer_id)
50
45
  assert_equal(0x42, msg.node.model_id)
51
- assert_equal(0x10, msg.node.device_id)
46
+ assert_equal(0x10, msg.node.device_id)
52
47
  assert_equal([0x40, 0x00, 0x7F], msg.address)
53
- assert_equal(0x10, msg.data)
48
+ assert_equal(0x10, msg.data)
54
49
  end
55
-
50
+
56
51
  def test_command
57
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
58
- msg = SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
52
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
53
+ msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x10, :node => node)
59
54
  assert_equal(node, msg.node)
60
55
  assert_equal([0x40, 0x7F, 0x00], msg.address)
61
- assert_equal(0x10, msg.data)
62
- end
63
-
56
+ assert_equal(0x10, msg.data)
57
+ end
58
+
64
59
  def test_request_byte_size
65
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
66
- msg = SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10, :node => node)
60
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
61
+ msg = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10, :node => node)
67
62
  assert_equal(node, msg.node)
68
63
  assert_equal([0x40, 0x7F, 0x00], msg.address)
69
64
  assert_equal([0x0, 0x0, 0x10], msg.size)
70
- end
71
-
65
+ end
66
+
72
67
  def test_request_array_size
73
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
74
- msg = SystemExclusive::Request.new([0x40, 0x7F, 0x00], [0x0, 0x9, 0x10], :node => node)
68
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
69
+ msg = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], [0x0, 0x9, 0x10], :node => node)
75
70
  assert_equal(node, msg.node)
76
71
  assert_equal([0x40, 0x7F, 0x00], msg.address)
77
- assert_equal([0x0, 0x9, 0x10], msg.size)
72
+ assert_equal([0x0, 0x9, 0x10], msg.size)
78
73
  end
79
74
 
80
75
  def test_request_numeric_size
81
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
82
- msg = SystemExclusive::Request.new([0x40, 0x7F, 0x00], 300, :node => node)
76
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
77
+ msg = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 300, :node => node)
83
78
  assert_equal(node, msg.node)
84
79
  assert_equal([0x40, 0x7F, 0x00], msg.address)
85
- assert_equal([0x0, 0x35, 0xF7], msg.size)
80
+ assert_equal([0x0, 0x35, 0xF7], msg.size)
86
81
  end
87
-
82
+
88
83
  def test_node_oriented
89
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
84
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
90
85
  msg = node.request([0x40, 0x7F, 0x00], 0x10)
91
86
  assert_equal(node, msg.node)
92
87
  assert_equal([0x40, 0x7F, 0x00], msg.address)
93
- assert_equal([0x0, 0x0, 0x10], msg.size)
88
+ assert_equal([0x0, 0x0, 0x10], msg.size)
94
89
  end
95
-
90
+
96
91
  def test_prototype
97
- prototype = SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10)
98
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
92
+ prototype = MIDIMessage::SystemExclusive::Request.new([0x40, 0x7F, 0x00], 0x10)
93
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
99
94
  msg = node.new_message_from(prototype)
100
95
  assert_equal(node, msg.node)
101
96
  assert_equal(prototype.address, msg.address)
102
97
  assert_equal(prototype.size, msg.size)
103
- end
104
-
105
- def test_checksum
106
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
107
- msg = SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
98
+ end
99
+
100
+ def test_checksum
101
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
102
+ msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
108
103
  assert_equal(0x41, msg.checksum)
109
104
  end
110
-
105
+
111
106
  def test_to_a
112
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
113
- msg = SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
107
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
108
+ msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
114
109
  assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], msg.to_bytes)
115
110
  end
116
-
111
+
117
112
  def test_to_s
118
- node = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
119
- msg = SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
113
+ node = MIDIMessage::SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
114
+ msg = MIDIMessage::SystemExclusive::Command.new([0x40, 0x00, 0x7F], 0x00, :node => node)
120
115
  assert_equal("F04110421240007F0041F7", msg.to_bytestr)
121
116
  end
122
-
123
- end
117
+
118
+ end