mvlc 0.0.1

data/test/instructions/player_test.rb

@@ -0,0 +1,66 @@
+require "helper"
+
+class MVLC::Instructions::PlayerTest < Minitest::Test
+
+  context "Player" do
+
+    setup do
+      @player = Object.new
+      @player.stubs(:quit)
+      @player.stubs(:seek).returns(true)
+      VLC::System.stubs(:new).returns(@player)
+      @input = Object.new
+      @context = MVLC::Context.new(@input)
+      assert @context.kind_of?(MVLC::Instructions::Player)
+    end
+
+    context "#on_end_of_file" do
+
+      setup do
+        @context.player.expects(:add_end_of_file_callback).once.returns({})
+      end
+
+      teardown do
+        @context.player.unstub(:add_end_of_file_callback)
+      end
+
+      should "assign callback" do
+        refute_nil @context.on_end_of_file { something }
+      end
+
+    end
+
+    context "#method_missing" do
+
+      setup do
+        @context.player.expects(:mplayer_send).once.with(:seek, 50, :percent).returns(true)
+      end
+
+      teardown do
+        @context.player.unstub(:mplayer_send)
+      end
+
+      should "delegate" do
+        refute_nil @context.seek(50, :percent)
+      end
+
+    end
+
+    context "#respond_to?" do
+
+      setup do
+        @context.player.expects(:mplayer_respond_to?).once.with(:seek).returns(true)
+      end
+
+      teardown do
+        @context.player.unstub(:mplayer_respond_to?)
+      end
+
+      should "delegate" do
+        refute_nil @context.respond_to?(:seek)
+      end
+
+    end
+
+  end
+end

data/test/midi/message_handler_test.rb

@@ -0,0 +1,315 @@
+require "helper"
+
+class MVLC::MIDI::MessageHandlerTest < Minitest::Test
+
+  context "MessageHandler" do
+
+    setup do
+      @handler = MVLC::MIDI::MessageHandler.new
+    end
+
+    context "#note_message" do
+
+      setup do
+        @message = MIDIMessage::NoteOn.new(0, 10, 100)
+      end
+
+      context "callback exists" do
+
+        setup do
+          @var = nil
+          @callback = proc { |vel| @var = vel }
+          @handler.add_callback(:note, @message.note, &@callback)
+          @callback.expects(:call).once
+        end
+
+        teardown do
+          @callback.unstub(:call)
+        end
+
+        context "has catch-all callback" do
+
+          setup do
+            @var2 = nil
+            @catchall = proc { |vel| @var2 = vel }
+            @handler.add_callback(:note, nil, &@catchall)
+            @catchall.expects(:call).once
+          end
+
+          teardown do
+            @catchall.unstub(:call)
+          end
+
+          should "call both callbacks" do
+            assert @handler.send(:note_message, @message)
+          end
+
+        end
+
+        context "no catch-all callback" do
+
+          should "call specific callback" do
+            assert @handler.send(:note_message, @message)
+          end
+
+        end
+
+      end
+
+      context "callback doesn't exist" do
+
+        context "has catch-all callback" do
+
+          setup do
+            @var = nil
+            @callback = proc { |vel| @var = vel }
+            @handler.add_callback(:note, nil, &@callback)
+            @callback.expects(:call).once
+          end
+
+          should "call callback" do
+            assert @handler.send(:note_message, @message)
+          end
+
+        end
+
+        context "no catch-all callback" do
+
+          should "do nothing" do
+            refute @handler.send(:note_message, @message)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "#cc_message" do
+
+      setup do
+        @message = MIDIMessage::ControlChange.new(0, 8, 100)
+      end
+
+      context "callback exists" do
+
+        setup do
+          @var = nil
+          @callback = proc { |vel| @var = vel }
+          @handler.add_callback(:cc, @message.index, &@callback)
+          @callback.expects(:call).once
+        end
+
+        teardown do
+          @callback.unstub(:call)
+        end
+
+        should "call callback" do
+          assert @handler.send(:cc_message, @message)
+        end
+
+      end
+
+      context "callback doesn't exist" do
+
+        context "has catch-all callback" do
+
+          setup do
+            @var = nil
+            @callback = proc { |vel| @var = vel }
+            @handler.add_callback(:cc, nil, &@callback)
+            @callback.expects(:call).once
+          end
+
+          should "call callback" do
+            assert @handler.send(:cc_message, @message)
+          end
+
+        end
+
+        context "no catch-all callback" do
+
+          should "do nothing" do
+            refute @handler.send(:cc_message, @message)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "#system_message" do
+
+      setup do
+        @message = MIDIMessage::SystemRealtime.new(0x8) # clock
+      end
+
+      context "callback exists" do
+
+        setup do
+          @var = nil
+          @callback = proc { |vel| @var = vel }
+          @handler.add_callback(:system, :clock, &@callback)
+          @callback.expects(:call).once
+        end
+
+        teardown do
+          @callback.unstub(:call)
+        end
+
+        should "call callback" do
+          assert @handler.send(:system_message, @message)
+        end
+
+      end
+
+      context "callback doesn't exist" do
+
+        should "do nothing" do
+          refute @handler.send(:system_message, @message)
+        end
+
+      end
+
+    end
+
+    context "#channel_message" do
+
+      context "omni" do
+
+        setup do
+          @channel = nil
+        end
+
+        context "control change" do
+
+          setup do
+            @message = MIDIMessage::ControlChange.new(0, 8, 100)
+            @handler.expects(:cc_message).once.with(@message).returns(true)
+          end
+
+          teardown do
+            @handler.unstub(:cc_message)
+          end
+
+          should "handle control change" do
+            assert @handler.send(:channel_message, @channel, @message)
+          end
+
+        end
+
+        context "note" do
+
+          setup do
+            @message = MIDIMessage::NoteOn.new(0, 10, 100)
+            @handler.expects(:note_message).once.with(@message).returns(true)
+          end
+
+          teardown do
+            @handler.unstub(:note_message)
+          end
+
+          should "handle note" do
+            assert @handler.send(:channel_message, @channel, @message)
+          end
+
+        end
+
+      end
+
+      context "with channel" do
+
+        setup do
+          @channel = 5
+        end
+
+        context "control change" do
+
+          setup do
+            @message = MIDIMessage::ControlChange.new(@channel, 8, 100)
+          end
+
+          context "matching channel" do
+
+            setup do
+              @handler.expects(:cc_message).once.with(@message).returns(true)
+            end
+
+            teardown do
+              @handler.unstub(:cc_message)
+            end
+
+            should "handle control change" do
+              assert @handler.send(:channel_message, @channel, @message)
+            end
+
+          end
+
+          context "non matching channel" do
+
+            setup do
+              @handler.expects(:cc_message).never
+              @other_message = MIDIMessage::ControlChange.new(@channel + 1, 8, 100)
+            end
+
+            teardown do
+              @handler.unstub(:cc_message)
+            end
+
+            should "do nothing" do
+              refute @handler.send(:channel_message, @channel, @other_message)
+            end
+
+          end
+
+        end
+
+        context "note" do
+
+          setup do
+            @message = MIDIMessage::NoteOn.new(@channel, 10, 100)
+          end
+
+          context "matching channel" do
+
+            setup do
+              @handler.expects(:note_message).once.with(@message).returns(true)
+            end
+
+            teardown do
+              @handler.unstub(:note_message)
+            end
+
+            should "call callback" do
+              assert @handler.send(:channel_message, @channel, @message)
+            end
+
+          end
+
+          context "non matching channel" do
+
+            setup do
+              @handler.expects(:note_message).never
+              @other_message = MIDIMessage::ControlChange.new(@channel + 1, 8, 100)
+            end
+
+            teardown do
+              @handler.unstub(:note_message)
+            end
+
+            should "not call callback" do
+              refute @handler.send(:channel_message, @channel, @other_message)
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/midi/wrapper_test.rb

@@ -0,0 +1,229 @@
+require "helper"
+
+class MVLC::MIDI::WrapperTest < Minitest::Test
+
+  context "Wrapper" do
+
+    setup do
+      @input = Object.new
+      @midi = MVLC::MIDI::Wrapper.new(@input)
+    end
+
+    context "#handle_new_event" do
+
+      context "with no buffer length" do
+
+        setup do
+          @midi.message_handler.expects(:process).once
+          @event = {
+            :message => MIDIMessage::NoteOn.new(0, 64, 120),
+            :timestamp=> 9266.395330429077
+          }
+          @result = @midi.send(:handle_new_event, @event)
+        end
+
+        teardown do
+          @midi.message_handler.unstub(:process)
+        end
+
+        should "return event" do
+          refute_nil @result
+          assert_equal @event, @result
+        end
+
+      end
+
+      context "with buffer length" do
+
+        context "recent message" do
+
+          setup do
+            @midi.message_handler.expects(:process).once
+            @event = {
+              :message => MIDIMessage::NoteOn.new(0, 64, 120),
+              :timestamp=> 9266.395330429077
+            }
+            @result = @midi.send(:handle_new_event, @event)
+          end
+
+          teardown do
+            @midi.message_handler.unstub(:process)
+          end
+
+          should "return event" do
+            refute_nil @result
+            assert_equal @event, @result
+          end
+
+        end
+
+        context "with too-old message" do
+
+          setup do
+            @midi.instance_variable_set("@buffer_length", 1)
+            @midi.instance_variable_set("@start_time", Time.now.to_i)
+            sleep(2)
+            @midi.message_handler.expects(:process).never
+            @event = {
+              :message => MIDIMessage::NoteOn.new(0, 64, 120),
+              :timestamp => 0.1
+            }
+            @result = @midi.send(:handle_new_event, @event)
+          end
+
+          teardown do
+            @midi.message_handler.unstub(:process)
+          end
+
+          should "not return event" do
+            assert_nil @result
+          end
+
+        end
+
+      end
+
+    end
+
+    context "#initialize_listener" do
+
+      setup do
+        @midi.listener.expects(:on_message).once
+        @result = @midi.send(:initialize_listener)
+      end
+
+      teardown do
+        @midi.listener.unstub(:on_message)
+      end
+
+      should "return listener" do
+        refute_nil @result
+        assert_equal MIDIEye::Listener, @result.class
+      end
+
+    end
+
+    context "#start" do
+
+      setup do
+        @midi.listener.expects(:on_message).once
+        @midi.listener.expects(:start).once
+      end
+
+      teardown do
+        @midi.listener.unstub(:on_message)
+        @midi.listener.unstub(:start)
+      end
+
+      should "activate callbacks" do
+        assert @midi.start
+      end
+
+    end
+
+    context "#add_note_callback" do
+
+      setup do
+        @var = nil
+        @midi.add_note_callback(10) { |vel| @var = vel }
+      end
+
+      should "store callback" do
+        refute_nil @midi.message_handler.callback[:note][10]
+        assert_equal Proc, @midi.message_handler.callback[:note][10].class
+      end
+
+    end
+
+    context "#add_system_callback" do
+
+      setup do
+        @var = nil
+        @midi.add_system_callback(:start) { |val| @var = val }
+      end
+
+      should "store callback" do
+        refute_nil @midi.message_handler.callback[:system][:start]
+        assert_equal Proc, @midi.message_handler.callback[:system][:start].class
+      end
+
+    end
+
+    context "#add_cc_callback" do
+
+      setup do
+        @var = nil
+        @midi.add_cc_callback(2) { |val| @var = val }
+      end
+
+      should "store callback" do
+        refute_nil @midi.message_handler.callback[:cc][2]
+        assert_equal Proc, @midi.message_handler.callback[:cc][2].class
+      end
+
+    end
+
+    context "#channel=" do
+
+      setup do
+        # stub out MIDIEye
+        @listener = Object.new
+        @listener.stubs(:event).returns([])
+        @midi.instance_variable_set("@listener", @listener)
+      end
+
+      teardown do
+        @listener.unstub(:clear)
+        @listener.unstub(:on_message)
+        @listener.unstub(:event)
+        @listener.unstub(:running?)
+      end
+
+      context "before listener is started" do
+
+        setup do
+          @listener.stubs(:running?).returns(false)
+          @listener.expects(:clear).never
+          @listener.expects(:on_message).never
+        end
+
+        should "change channel" do
+          assert_equal 3, @midi.channel = 3
+          assert_equal 3, @midi.channel
+          refute @midi.omni?
+        end
+
+        should "set channel nil" do
+          assert_nil @midi.channel = nil
+          assert_nil @midi.channel
+          assert @midi.omni?
+        end
+      end
+
+      context "after listener is started" do
+
+        setup do
+          @listener.stubs(:running?).returns(true)
+          @listener.expects(:clear).once
+          @listener.expects(:on_message).once
+        end
+
+        should "change channel" do
+          assert_equal 3, @midi.channel = 3
+          assert_equal 3, @midi.channel
+          refute @midi.omni?
+        end
+
+        should "set channel nil" do
+          assert_nil @midi.channel = nil
+          assert_nil @midi.channel
+          assert @midi.omni?
+        end
+
+      end
+
+    end
+
+  end
+
+end