gstreamer 0.90.6

data/test/gst-test-utils.rb

@@ -0,0 +1,18 @@
+module GstTestUtils
+  private
+  def only_gst_version(major, minor, micro)
+    unless Gst.check_version?(major, minor, micro)
+      omit("Require GStreamer >= #{major}.#{minor}.#{micro}")
+    end
+  end
+
+  def find_element_factory(name)
+    factory = Gst::ElementFactory.find(name)
+    assert_not_nil(factory, "#{name}'s factory should be found.")
+    factory
+  end
+
+  def create_element(element_name, name=nil)
+    find_element_factory(element_name).create(name)
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+# ENV["GST_DEBUG"] = "GST_BUFFER:5"
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+if system("which make > /dev/null")
+  system("cd #{base_dir.dump} && make > /dev/null") or exit(1)
+end
+
+glib_dir = File.expand_path(File.join(base_dir, "..", "glib2"))
+$LOAD_PATH.unshift(File.join(glib_dir, "test"))
+require 'glib-test-init'
+
+$LOAD_PATH.unshift(File.join(glib_dir, "ext", "glib2"))
+$LOAD_PATH.unshift(File.join(glib_dir, "lib"))
+
+$LOAD_PATH.unshift(File.join(base_dir, "src"))
+$LOAD_PATH.unshift(File.join(base_dir, "src", "lib"))
+require "gst"
+
+$LOAD_PATH.unshift(File.join(base_dir, "test"))
+require 'gst-test-utils'
+
+exit Test::Unit::AutoRunner.run(true)

data/test/test_bin.rb

@@ -0,0 +1,167 @@
+class TestBin < Test::Unit::TestCase
+  include GstTestUtils
+
+  def test_children
+    bin = Gst::Bin.new
+
+    element = create_element("filesink")
+    no_interface_element = create_element("fakesink")
+    bin << element << no_interface_element
+
+    assert_equal([no_interface_element, element], bin.children)
+    assert_equal([element], bin.children(Gst::ElementURIHandler))
+  end
+
+  def test_size
+    bin = Gst::Bin.new
+    assert_equal(0, bin.size)
+    bin << create_element("fakesink")
+    assert_equal(1, bin.size)
+  end
+
+  def test_children_cookie
+    bin = Gst::Bin.new
+    cookie = bin.children_cookie
+    assert_equal(cookie, bin.children_cookie)
+    bin << create_element("fakesink")
+    assert_not_equal(cookie, bin.children_cookie)
+  end
+
+  def test_child_bus
+    bin = Gst::Bin.new
+    assert_not_nil(bin.child_bus)
+  end
+
+  def test_messages
+    bin = Gst::Bin.new
+    assert_equal([], bin.messages)
+  end
+
+  def test_polling?
+    bin = Gst::Bin.new
+    assert(!bin.polling?)
+  end
+
+  def test_clock_dirty?
+    bin = Gst::Bin.new
+    assert(!bin.clock_dirty?)
+  end
+
+  def test_provided_clock
+    bin = Gst::Bin.new
+    assert_nil(bin.provided_clock)
+    bin.provided_clock = Gst::SystemClock.new
+    assert_not_nil(bin.provided_clock)
+    bin.provided_clock = nil
+    assert_nil(bin.provided_clock)
+  end
+
+  def test_clock_provider
+    bin = Gst::Bin.new
+    assert_nil(bin.clock_provider)
+  end
+
+  def test_add
+    bin = Gst::Bin.new
+    element = create_element("fakesink")
+    bin << element
+    assert_equal(element, bin.children[0])
+    assert_raise(TypeError) do
+      bin << "XXX"
+    end
+
+    element2 = create_element("fakesink")
+    element3 = create_element("fakesink")
+    bin.add(element2, element3)
+    assert_equal([element3, element2], bin.children[0, 2])
+  end
+
+  def test_remove
+    bin = Gst::Bin.new
+    element1 = create_element("fakesink")
+    element2 = create_element("fakesink")
+    bin << element1 << element2
+    assert_equal(2, bin.size)
+    bin.remove(element1, element2)
+    assert_equal(0, bin.size)
+  end
+
+  def test_clear
+    bin = Gst::Bin.new
+    element1 = create_element("fakesink")
+    element2 = create_element("fakesink")
+    bin << element1 << element2
+    assert_equal(2, bin.size)
+    bin.clear
+    assert_equal(0, bin.size)
+  end
+
+  def test_refer_by_name
+    bin = Gst::Bin.new
+    sub_bin = Gst::Bin.new
+    bin << sub_bin
+
+    element = create_element("fakesink")
+    assert_nil(bin.get_child(element.name))
+    assert_nil(sub_bin.get_child(element.name))
+    assert_nil(sub_bin.get_child(element.name, true))
+
+    bin << element
+    assert_equal(element, bin.get_child(element.name))
+    assert_equal(element, bin.get_child(element.name, true))
+    assert_nil(sub_bin.get_child(element.name))
+    assert_equal(element, sub_bin.get_child(element.name, true))
+  end
+
+  def test_refer_by_interface
+    bin = Gst::Bin.new
+    element = create_element("filesink")
+
+    assert_nil(bin.get_child(Gst::ElementURIHandler))
+
+    bin << create_element("fakesink")
+    assert_nil(bin.get_child(Gst::ElementURIHandler))
+
+    bin << element
+    assert_equal(element, bin.get_child(Gst::ElementURIHandler))
+  end
+
+  def test_refer_by_index
+    bin = Gst::Bin.new
+    element1 = create_element("filesink")
+    element2 = create_element("fakesink")
+
+    assert_nil(bin.get_child(0))
+    assert_nil(bin.get_child(1))
+    assert_nil(bin.get_child(2))
+
+    bin << element1 << element2
+    assert_equal(element2, bin.get_child(0))
+    assert_equal(element1, bin.get_child(1))
+    assert_nil(bin.get_child(2))
+  end
+
+  def test_sinks
+    bin = Gst::Bin.new
+    sink1 = create_element("filesink")
+    sink2 = create_element("fakesink")
+    src = create_element("fakesrc")
+
+    assert_equal([], bin.sinks)
+
+    bin << src << sink1 << sink2
+    assert_equal([sink2, sink1], bin.sinks)
+  end
+
+  def test_sources
+    bin = Gst::Bin.new
+    src1 = create_element("filesrc")
+    src2 = create_element("fakesrc")
+    sink = create_element("fakesink")
+
+    assert_equal([], bin.sources)
+
+    bin << src1 << src2 << sink
+    assert_equal([src2, src1], bin.sources)
+  end
+end

data/test/test_buffer.rb

@@ -0,0 +1,174 @@
+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)
+
+    caps = Gst::Caps.new
+    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
+    assert_equal(Gst::Buffer::CopyFlags::FLAGS |
+                 Gst::Buffer::CopyFlags::TIMESTAMPS |
+                 Gst::Buffer::CopyFlags::CAPS,
+                 Gst::Buffer::CopyFlags::ALL)
+
+    assert_equal(Gst::Buffer::COPY_FLAGS |
+                 Gst::Buffer::COPY_TIMESTAMPS |
+                 Gst::Buffer::COPY_CAPS,
+                 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(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

@@ -0,0 +1,24 @@
+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_clock.rb

@@ -0,0 +1,7 @@
+class TestClock < Test::Unit::TestCase
+  def test_create_clock
+    assert_raise(TypeError) do
+      Gst::Clock.new
+    end
+  end
+end

data/test/test_element.rb

@@ -0,0 +1,87 @@
+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("videotestsrc")
+    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_ASYNC,
+                  Gst::STATE_READY,
+                  Gst::STATE_PLAYING],
+                 pipeline.get_state(10))
+
+    pipeline.pause
+    assert_equal([Gst::STATE_CHANGE_ASYNC,
+                  Gst::STATE_READY,
+                  Gst::STATE_PAUSED],
+                 pipeline.get_state(10))
+
+    pipeline.stop
+    assert_equal([Gst::STATE_CHANGE_SUCCESS,
+                  Gst::STATE_NULL,
+                  Gst::STATE_VOID_PENDING],
+                 pipeline.get_state(10))
+
+    pipeline.set_state(:playing)
+    pend("Async is correct behavior?") do
+      assert_equal([Gst::STATE_CHANGE_SUCCESS,
+                    Gst::STATE_PLAYING,
+                    Gst::STATE_VOID_PENDING],
+                   pipeline.get_state(10))
+    end
+  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