gstreamer 1.2.6 → 2.0.0

data/test/test_buffer.rb

@@ -1,185 +0,0 @@
-class TestBuffer < Test::Unit::TestCase
-  def test_create_mini_object
-    assert_nothing_raised do
-      Gst::Buffer.new
-    end
-  end
-
-  def test_flag
-    buffer = Gst::Buffer.new
-
-    assert_nothing_raised do
-      buffer.raise_flag(:preroll)
-    end
-    assert(!buffer.flag_raised?(:discont))
-    assert_nothing_raised do
-      buffer.lower_flag(:in_caps)
-    end
-
-    buffer.flags = [:gap, :delta_unit]
-    assert_equal(Gst::Buffer::FLAG_GAP | Gst::Buffer::FLAG_DELTA_UNIT,
-                 buffer.flags)
-  end
-
-  def test_size
-    assert_equal(0, Gst::Buffer.new.size)
-    buffer = Gst::Buffer.new(5)
-    assert_equal(5, buffer.size)
-    buffer.size = 3
-    assert_equal(3, buffer.size)
-  end
-
-  def test_data
-    buffer = Gst::Buffer.new
-    assert_equal([nil, 0], [buffer.data, buffer.size])
-    buffer.data = "XXX"
-    assert_equal(["XXX", 3], [buffer.data, buffer.size])
-    buffer.data = nil
-    assert_equal([nil, 0], [buffer.data, buffer.size])
-  end
-
-  def test_timestamp
-    buffer = Gst::Buffer.new
-    assert_equal(Gst::ClockTime::NONE, buffer.timestamp)
-    assert(!buffer.valid_timestamp?)
-
-    timestamp = Time.now.to_i * Gst::NSECOND
-    buffer.timestamp = timestamp
-    assert_equal(timestamp, buffer.timestamp)
-    assert(buffer.valid_timestamp?)
-  end
-
-  def test_duration
-    buffer = Gst::Buffer.new
-    assert_equal(Gst::ClockTime::NONE, buffer.duration)
-    assert(!buffer.valid_duration?)
-
-    duration = 10 * 60 * Gst::NSECOND
-    buffer.duration = duration
-    assert_equal(duration, buffer.duration)
-    assert(buffer.valid_duration?)
-  end
-
-  def test_caps
-    buffer = Gst::Buffer.new
-    assert_nil(buffer.caps)
-
-    structure = Gst::Structure.new("caps")
-    structure["width"] = 320
-    structure["height"] = 240
-    caps = Gst::Caps.new(structure)
-    buffer.caps = caps
-    assert_equal(caps, buffer.caps)
-  end
-
-  def test_offset
-    buffer = Gst::Buffer.new
-    assert_equal(Gst::Buffer::OFFSET_NONE, buffer.offset)
-    assert(!buffer.valid_offset?)
-
-    offset = 10
-    buffer.offset = offset
-    assert_equal(offset, buffer.offset)
-    assert(buffer.valid_offset?)
-  end
-
-  def test_offset_end
-    buffer = Gst::Buffer.new
-    assert_equal(Gst::Buffer::OFFSET_NONE, buffer.offset_end)
-    assert(!buffer.valid_offset_end?)
-
-    offset_end = 10
-    buffer.offset_end = offset_end
-    assert_equal(offset_end, buffer.offset_end)
-    assert(buffer.valid_offset_end?)
-  end
-
-  def test_discontinuity
-    buffer = Gst::Buffer.new
-    assert(!buffer.discontinuity?)
-
-    buffer.raise_flag(:discont)
-    assert(buffer.discontinuity?)
-  end
-
-  def test_copy_flags
-    all_flags =
-      Gst::Buffer::CopyFlags::FLAGS |
-      Gst::Buffer::CopyFlags::TIMESTAMPS |
-      Gst::Buffer::CopyFlags::CAPS
-    all_flags_shortcut =
-      Gst::Buffer::COPY_FLAGS |
-      Gst::Buffer::COPY_TIMESTAMPS |
-      Gst::Buffer::COPY_CAPS
-    if Gst::Buffer::CopyFlags.const_defined?(:QDATA)
-      all_flags |= Gst::Buffer::CopyFlags::QDATA
-      all_flags_shortcut |= Gst::Buffer::COPY_QDATA
-    end
-
-    assert_equal(all_flags,
-                 Gst::Buffer::CopyFlags::ALL)
-    assert_equal(all_flags_shortcut,
-                 Gst::Buffer::COPY_ALL)
-  end
-
-  def test_copy_metadata
-    buffer = Gst::Buffer.new
-    buffer.flags = :discont
-
-    copied = buffer.copy_metadata(:all)
-    assert(copied.flag_raised?(:discont))
-    copied = buffer.copy_metadata(0)
-    assert(!copied.flag_raised?(:discont))
-
-    copied = Gst::Buffer.new
-    assert(!copied.flag_raised?(:discont))
-    buffer.copy_metadata(copied, :flags)
-    assert(copied.flag_raised?(:discont))
-  end
-
-  def test_copy_metadata_with_readonly
-    buffer = Gst::Buffer.new
-    buffer.flags = :readonly
-    assert(!buffer.writable?)
-
-    copied = buffer.copy_metadata(:all)
-    assert(!copied.flag_raised?(:readonly))
-    assert(copied.writable?)
-  end
-
-  def test_metadata_writable
-    buffer = Gst::Buffer.new
-    assert(buffer.metadata_writable?)
-    buffer.metadata_writable!
-    # assert(buffer.metadata_writable?) # FIXME
-
-    buffer = Gst::Buffer.new
-    buffer.create_sub(0, 0)
-    assert(!buffer.metadata_writable?)
-    buffer.metadata_writable!
-    # assert(buffer.metadata_writable?) # FIXME
-
-    buffer = Gst::Buffer.new
-    sub = buffer.create_sub(0, 0)
-    assert(!sub.metadata_writable?)
-    sub.metadata_writable!
-    # assert(sub.metadata_writable?) # FIXME
-  end
-
-  def test_span
-    buffer1 = Gst::Buffer.new(5)
-    buffer2 = Gst::Buffer.new(10)
-
-    length = 7
-    merged_buffer = buffer1.span(2, buffer2, length)
-    assert_equal(length, merged_buffer.length)
-  end
-
-  def test_span?
-    buffer = Gst::Buffer.new
-    sub_buffer1 = buffer.create_sub(0, 0)
-    sub_buffer2 = buffer.create_sub(0, 0)
-    assert(sub_buffer1.span?(sub_buffer2))
-    assert(!buffer.span?(sub_buffer1))
-  end
-end

data/test/test_caps.rb

@@ -1,24 +0,0 @@
-class TestCaps < Test::Unit::TestCase
-  def test_size
-    assert_equal(1, smpte_caps.size)
-  end
-
-  def test_get_structure
-    assert_equal("video/x-raw-yuv", smpte_caps[0].name)
-  end
-
-  def test_each
-    assert_equal(["video/x-raw-yuv"],
-                 smpte_caps.collect {|structure| structure.name})
-  end
-
-  private
-  def smpte_caps
-    smpte = Gst::ElementFactory.find("smpte")
-    assert_not_nil(smpte)
-    smpte.pad_templates.find do |template|
-      template.direction == Gst::Pad::SRC
-    end.caps.to_caps
-  end
-end
-

data/test/test_element.rb

@@ -1,85 +0,0 @@
-class TestElement < Test::Unit::TestCase
-  include GstTestUtils
-
-  class TestBin < Gst::Bin
-    type_register
-  end
-
-
-  def test_clock
-    bin = create_element("playbin")
-    assert(bin.require_clock?)
-    assert(bin.provide_clock?)
-    assert_nil(bin.clock)
-  end
-
-  def test_each_pad
-    pads = []
-    create_element("filesrc").each_pad do |pad|
-      pads << pad.name
-    end
-    assert_equal(["src"], pads)
-  end
-
-  def test_state
-    pipeline = Gst::Pipeline.new
-    src = create_element("fakesrc")
-    sink = create_element("fakesink")
-    pipeline.add(src, sink)
-
-    assert_equal([Gst::STATE_CHANGE_SUCCESS,
-                  Gst::STATE_NULL,
-                  Gst::STATE_VOID_PENDING],
-                 pipeline.get_state)
-
-    pipeline.ready
-    assert_equal([Gst::STATE_CHANGE_SUCCESS,
-                  Gst::STATE_READY,
-                  Gst::STATE_VOID_PENDING],
-                 pipeline.get_state)
-
-    pipeline.play
-    assert_equal([Gst::STATE_CHANGE_FAILURE,
-                  Gst::STATE_READY,
-                  Gst::STATE_PLAYING],
-                 pipeline.get_state)
-
-    pipeline.pause
-    assert_equal([Gst::STATE_CHANGE_ASYNC,
-                  Gst::STATE_READY,
-                  Gst::STATE_PAUSED],
-                 pipeline.get_state(1))
-
-    pipeline.stop
-    assert_equal([Gst::STATE_CHANGE_SUCCESS,
-                  Gst::STATE_NULL,
-                  Gst::STATE_VOID_PENDING],
-                 pipeline.get_state)
-
-    pipeline.set_state(:playing)
-    assert_equal([Gst::STATE_CHANGE_FAILURE,
-                  Gst::STATE_READY,
-                  Gst::STATE_PLAYING],
-                 pipeline.get_state)
-  end
-
-  def test_query
-    pipeline = Gst::Pipeline.new
-    assert_boolean(pipeline.query(Gst::QueryFormats.new))
-  end
-
-  def test_send_event
-    pipeline = Gst::Pipeline.new
-    assert_boolean(pipeline.send_event(Gst::EventEOS.new))
-  end
-
-  def test_reference_counting
-    pipeline = Gst::Pipeline.new
-    bin = TestBin.new
-
-    10.times do
-      pipeline.add(bin)
-      pipeline.remove(bin)
-    end
-  end
-end

data/test/test_element_factory.rb

@@ -1,28 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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_install-plugins.rb

@@ -1,18 +0,0 @@
-class TestInstallPlugins < Test::Unit::TestCase
-  def test_create_return
-    assert_nothing_raised do
-      Gst::InstallPluginsReturn.new(Gst::InstallPluginsReturn::SUCCESS)
-    end
-  end
-
-  def test_return_name
-    ret = Gst::InstallPluginsReturn.new(Gst::InstallPluginsReturn::SUCCESS)
-    assert_equal("success", ret.name)
-  end
-
-  def test_create_context
-    assert_nothing_raised do
-      Gst::InstallPluginsContext.new
-    end
-  end
-end

data/test/test_message.rb

@@ -1,191 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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