gstreamer 0.90.6

data/test/test_element_factory.rb

@@ -0,0 +1,28 @@
+class TestElementFactory < Test::Unit::TestCase
+  include GstTestUtils
+
+  def test_long_name
+    assert_equal("Player Bin", play_bin.long_name)
+  end
+
+  def test_klass
+    assert_equal("Generic/Bin/Player", play_bin.klass)
+  end
+
+  def test_description
+    assert_equal("Autoplug and play media from an uri", play_bin.description)
+  end
+
+  def test_author
+    assert_match(/\AWim Taymans <.*?>\z/, play_bin.author)
+  end
+
+  def test_create
+    assert_match(/\Aplaybin\d+\z/, play_bin.create.name)
+  end
+
+  private
+  def play_bin
+    find_element_factory("playbin")
+  end
+end

data/test/test_event.rb

@@ -0,0 +1,10 @@
+class TestEvent < Test::Unit::TestCase
+  include GstTestUtils
+
+  def test_type
+    assert_operator(Gst, :const_defined?, :EventType)
+    assert_nothing_raised do
+      Gst::Event::EOS
+    end
+  end
+end

data/test/test_index_factory.rb

@@ -0,0 +1,7 @@
+class TestIndexFactory < Test::Unit::TestCase
+  def test_description
+    index = Gst::IndexFactory.find("fileindex")
+    assert_not_nil(index)
+    assert_equal("A index that stores entries in file", index.description)
+  end
+end

data/test/test_message.rb

@@ -0,0 +1,191 @@
+class TestMessage < Test::Unit::TestCase
+  def test_create_message
+    assert_nothing_raised do
+      Gst::Message.new(:unknown, nil, nil)
+    end
+  end
+
+  def test_message_eos
+    assert_nothing_raised do
+      Gst::MessageEos.new(nil)
+    end
+  end
+
+  def test_message_error
+    return "FIXME" if true
+    error = nil
+    debug = "ERROR"
+    message = Gst::MessageError.new(nil, error, debug)
+    assert_equal([error, debug], message.parse)
+  end
+
+  def test_message_warning
+    return "FIXME" if true
+    error = nil
+    debug = "WARNING"
+    message = Gst::MessageWarning.new(nil, error, debug)
+    assert_equal([error, debug], message.parse)
+  end
+
+  def test_message_info
+    return "FIXME" if true
+    error = nil
+    debug = "INFO"
+    message = Gst::MessageInfo.new(nil, error, debug)
+    assert_equal([error, debug], message.parse)
+  end
+
+  def test_message_tag
+    return "FIXME" if true
+    tag_list = []
+    message = Gst::MessageTag.new(nil, tag_list)
+    assert_equal(tag_list, message.parse)
+  end
+
+  def test_message_buffering
+    percent = 50
+    message = Gst::MessageBuffering.new(nil, percent)
+    assert_equal(percent, message.parse)
+  end
+
+  def test_message_state_changed
+    old = Gst::STATE_PAUSED
+    new = Gst::STATE_PLAYING
+    pending = Gst::STATE_VOID_PENDING
+    message = Gst::MessageStateChanged.new(nil, :paused, :playing, :void_pending)
+    assert_equal([old, new, pending], message.parse)
+  end
+
+  def test_message_state_dirty
+    assert_nothing_raised do
+      Gst::MessageStateDirty.new(nil)
+    end
+  end
+
+  def test_message_clock_provide
+    clock = Gst::SystemClock.obtain
+    ready = true
+    message = Gst::MessageClockProvide.new(nil, clock, ready)
+    assert_equal([clock, ready], message.parse)
+  end
+
+  def test_message_clock_lost
+    clock = Gst::SystemClock.obtain
+    message = Gst::MessageClockLost.new(nil, clock)
+    assert_equal(clock, message.parse)
+  end
+
+  def test_create_message_new_clock
+    clock = Gst::SystemClock.obtain
+    message = Gst::MessageNewClock.new(nil, clock)
+    assert_equal(clock, message.parse)
+  end
+
+  def test_message_application
+    assert_nothing_raised do
+      Gst::MessageApplication.new(nil, nil)
+    end
+  end
+
+  def test_message_element
+    assert_nothing_raised do
+      Gst::MessageElement.new(nil, nil)
+    end
+  end
+
+  def test_missing_message_installer_detail
+    pipeline = Gst::Pipeline.new
+    message = Gst::MissingURISourceMessage.new(pipeline, "http")
+    assert_match(/HTTP/, message.installer_detail)
+  end
+
+  def test_missing_message_description
+    pipeline = Gst::Pipeline.new
+    message = Gst::MissingURISourceMessage.new(pipeline, "http")
+    assert_match(/HTTP/, message.description)
+  end
+
+  def test_message_segment_start
+    format = Gst::Format::DEFAULT
+    position = 100
+    message = Gst::MessageSegmentStart.new(nil, :default, position)
+    assert_equal([format, position], message.parse)
+  end
+
+  def test_message_segment_done
+    format = Gst::Format::DEFAULT
+    position = 100
+    message = Gst::MessageSegmentDone.new(nil, :default, position)
+    assert_equal([format, position], message.parse)
+  end
+
+  def test_message_duration
+    format = Gst::Format::DEFAULT
+    duration = 10
+    message = Gst::MessageDuration.new(nil, :default, duration)
+    assert_equal([format, duration], message.parse)
+  end
+
+  def test_message_async_start
+    new_base_time = true
+    message = Gst::MessageAsyncStart.new(nil, new_base_time)
+    assert_equal(new_base_time, message.parse)
+  end
+
+  def test_message_async_done
+    assert_nothing_raised do
+      Gst::MessageAsyncDone.new(nil)
+    end
+  end
+
+  def test_message_latency
+    assert_nothing_raised do
+      Gst::MessageLatency.new(nil)
+    end
+  end
+
+  def test_type
+    message = Gst::Message.new(:unknown, nil, nil)
+    assert_equal(Gst::Message::UNKNOWN, message.type)
+    message.type = :tag
+    assert_equal(Gst::Message::TAG, message.type)
+    assert_equal("tag", message.type.name)
+  end
+
+  def test_lock
+    message = Gst::MessageEos.new(nil)
+    assert(!message.have_mutex?)
+  end
+
+  def test_cond
+    message = Gst::MessageEos.new(nil)
+    assert(!message.have_cond?)
+  end
+
+  def test_timestamp
+    message = Gst::MessageEos.new(nil)
+    assert(!message.valid_timestamp?)
+
+    timestamp = Time.now.to_i * Gst::NSECOND
+    message.timestamp = timestamp
+    assert_equal(timestamp, message.timestamp)
+    assert(message.valid_timestamp?)
+  end
+
+  def test_source
+    assert_nil(Gst::MessageEos.new(nil).source)
+
+    source = Gst::XML.new
+    message = Gst::MessageEos.new(source)
+    assert_equal(source, message.source)
+    message.source = nil
+    assert_nil(message.source)
+  end
+
+  def test_structure
+    assert_nil(Gst::MessageEos.new(nil).structure)
+
+    message = Gst::Message.new(:unknown, nil, nil)
+    assert_nil(message.structure)
+  end
+end

data/test/test_mini_object.rb

@@ -0,0 +1,38 @@
+class TestMiniObject < Test::Unit::TestCase
+  def test_create_mini_object
+    assert_raise(TypeError) do
+      Gst::MiniObject.new
+    end
+
+    assert_operator(Gst::MiniObject, :>, Gst::Buffer)
+    assert_nothing_raised do
+      Gst::Buffer.new
+    end
+  end
+
+  def test_writable
+    mini_object = Gst::Buffer.new
+    assert(mini_object.writable?)
+    mini_object.flags = :readonly
+    assert(!mini_object.writable?)
+    mini_object.writable!
+    assert(mini_object.writable?)
+  end
+
+  def test_flag
+    mini_object = Gst::Buffer.new
+
+    assert_equal(0, mini_object.flags)
+    assert(!mini_object.flag_raised?(:readonly))
+
+    mini_object.raise_flag(:readonly)
+    assert(mini_object.flag_raised?(:readonly))
+    mini_object.lower_flag(:readonly)
+    assert(!mini_object.flag_raised?(:readonly))
+
+    mini_object.raise_flag(:readonly)
+    assert(mini_object.flag_raised?(:readonly))
+    mini_object.flags = 0
+    assert(!mini_object.flag_raised?(:readonly))
+  end
+end

data/test/test_object.rb

@@ -0,0 +1,10 @@
+class TestObject < Test::Unit::TestCase
+  include GstTestUtils
+
+  def test_name
+    sink = create_element("fakesink", "my-fakesink")
+    assert_equal("my-fakesink", sink.name)
+    sink.name += "0"
+    assert_equal("my-fakesink0", sink.name)
+  end
+end

data/test/test_pad.rb

@@ -0,0 +1,68 @@
+class TestPad < Test::Unit::TestCase
+  include GstTestUtils
+
+  def test_link
+    file_src = create_element("filesrc")
+    audio_convert = create_element("audioconvert")
+    audio_resample = create_element("audioresample")
+    file_sink = create_element("filesink")
+
+    current_linked = Proc.new do
+      [
+       file_src["src"].linked?,
+       audio_convert["sink"].linked?,
+       audio_convert["src"].linked?,
+       audio_resample["sink"].linked?,
+       audio_resample["src"].linked?,
+       file_sink["sink"].linked?,
+      ]
+    end
+
+    current_peer = Proc.new do
+      [
+       file_src["src"].peer,
+       audio_convert["sink"].peer,
+       audio_convert["src"].peer,
+       audio_resample["sink"].peer,
+       audio_resample["src"].peer,
+       file_sink["sink"].peer,
+      ]
+    end
+
+    assert_equal([false, false, false, false, false, false],
+                 current_linked.call)
+    assert_equal([nil, nil, nil, nil, nil, nil],
+                 current_peer.call)
+
+    file_src["src"].link(audio_convert["sink"])
+    assert_equal([true, true, false, false, false, false],
+                 current_linked.call)
+    assert_equal([audio_convert["sink"], file_src["src"], nil, nil, nil, nil],
+                 current_peer.call)
+
+    audio_convert["src"] >> audio_resample["sink"]
+    assert_equal([true, true, true, true, false, false],
+                 current_linked.call)
+    assert_equal([audio_convert["sink"], file_src["src"],
+                  audio_resample["sink"], audio_convert["src"],
+                  nil, nil],
+                 current_peer.call)
+
+    audio_resample["src"] >> file_sink["sink"]
+    assert_equal([true, true, true, true, true, true],
+                 current_linked.call)
+    assert_equal([audio_convert["sink"], file_src["src"],
+                  audio_resample["sink"], audio_convert["src"],
+                  file_sink["sink"], audio_resample["src"]],
+                 current_peer.call)
+
+    audio_convert["src"].unlink(audio_resample["sink"])
+    assert_equal([true, true, false, false, true, true],
+                 current_linked.call)
+    assert_equal([audio_convert["sink"], file_src["src"],
+                  nil, nil,
+                  file_sink["sink"], audio_resample["src"]],
+                 current_peer.call)
+  end
+end
+

data/test/test_plugin.rb

@@ -0,0 +1,6 @@
+class TestPlugin < Test::Unit::TestCase
+  def test_source
+    plugin = Gst::Registry.default.find_plugin("playback")
+    assert_equal("gst-plugins-base", plugin.source)
+  end
+end

data/test/test_plugin_feature.rb

@@ -0,0 +1,20 @@
+class TestPluginFeature < Test::Unit::TestCase
+  def test_load!
+    feature = Gst::ElementFactory.find("audiorate")
+    assert(!feature.loaded?)
+    assert(feature.load!)
+    assert(feature.loaded?)
+  end
+
+  def test_rank
+    feature = Gst::ElementFactory.find("playbin")
+    assert_equal(Gst::RANK_NONE, feature.rank)
+    feature.rank = :primary
+    assert_equal(Gst::RANK_PRIMARY, feature.rank)
+  end
+
+  def test_plugin_name
+    feature = Gst::ElementFactory.find("playbin")
+    assert_equal("playback", feature.plugin_name)
+  end
+end

data/test/test_seek.rb

@@ -0,0 +1,17 @@
+class TestSeek < Test::Unit::TestCase
+  include GstTestUtils
+
+  def test_type
+    assert_operator(Gst, :const_defined?, :SeekType)
+    assert_nothing_raised do
+      Gst::Seek::TYPE_NONE
+    end
+  end
+
+  def test_flags
+    assert_operator(Gst, :const_defined?, :SeekFlags)
+    assert_nothing_raised do
+      Gst::Seek::FLAG_NONE
+    end
+  end
+end

data/test/test_static_caps.rb

@@ -0,0 +1,18 @@
+class TestStaticCaps < Test::Unit::TestCase
+  def test_description
+    assert_equal("ANY", file_src_caps.description)
+  end
+
+  def test_to_caps
+    static_caps = file_src_caps
+    assert_kind_of(Gst::StaticCaps, static_caps)
+    assert_kind_of(Gst::Caps, static_caps.to_caps)
+  end
+
+  private
+  def file_src_caps
+    file_src = Gst::ElementFactory.find("filesrc")
+    assert_not_nil(file_src)
+    file_src.pad_templates[0].caps
+  end
+end

data/test/test_static_pad_template.rb

@@ -0,0 +1,16 @@
+class TestStaticPadTemplate < Test::Unit::TestCase
+  def test_reader
+    templates = file_src.pad_templates.collect do |template|
+      [template.name, template.direction, template.presence]
+    end
+    assert_equal([["src", Gst::Pad::SRC, Gst::Pad::ALWAYS]],
+                 templates)
+  end
+
+  private
+  def file_src
+    file_src = Gst::ElementFactory.find("filesrc")
+    assert_not_nil(file_src)
+    file_src
+  end
+end