Class/Module Index [+]

Quicksearch

TC_elements

Public Instance Methods

__create_bin(name) click to toggle source
# File gstreamer/tests/tc_element.rb, line 133
def __create_bin(name)
    b = Gst::Pipeline.new(name)
    e1 = Gst::ElementFactory.make("fakesrc") 
    e2 = Gst::ElementFactory.make("fakesink")
    e1 >> e2
    b.add(e1, e2)
    b
end
test_bin() click to toggle source
# File gstreamer/tests/tc_element.rb, line 87
def test_bin
    assert_instance_of(Gst::Bin, b = Gst::Bin.new("my bin"))
    b.test(self)
    # Test signals
    #b.signal_connect("element-added") { puts "element added!" }
    # Test container
    assert_equal(0, b.size)
    100.times { |i| b.add(Gst::ElementFactory.make("mad")) }
    assert_equal(b.size, 100)
    i = 0
    b.each_element { |e| assert_instance_of(Gst::Element, e); i += 1 }
    assert_equal(b.size, i)
    b.clear
    assert_equal(b.size, 0)
    a = Array.new
    100.times { a.push(Gst::ElementFactory.make("fakesrc")) }
    assert_equal(a.length, 100)
    b.add(*a)
    assert_equal(b.size, b.length)
    assert_equal(b.size, 100)
    assert_instance_of(Array, a = b.elements)
    assert_equal(a.length, 100)
    a.each { |e| assert_instance_of(Gst::Element, e) }
    b.remove(*a[0, 50])
    assert_equal(b.size, b.length)
    assert_equal(b.size, 50)
    b.remove_all
    assert_equal(b.size, b.length)
    assert_equal(b.size, 0)
    # Test unique auto-generated bins names
    a = Array.new
    10.times { a.push(Gst::Bin.new) }
    a.each { |e| assert_instance_of(Gst::Bin, e) }
    assert_nil a.collect { |e| e.name }.uniq! 
end
test_bin2() click to toggle source
# File gstreamer/tests/tc_element.rb, line 122
def test_bin2
    assert_instance_of(Gst::Bin, b = Gst::Bin.new)
    assert_instance_of(Gst::Element, e1 = Gst::ElementFactory.make("fakesrc", "fake1")) 
    assert_instance_of(Gst::Element, e2 = Gst::ElementFactory.make("fakesrc", "fake2")) 
    b.add(e1, e2)
    assert b.size == 2
    [ "fake1", "fake2" ].each do |x|
        assert_instance_of(Gst::Element, b.get_by_name(x))
        assert_instance_of(Gst::Element, b.get_by_name_recurse_up(x))
    end
end
test_bin_iterate() click to toggle source
# File gstreamer/tests/tc_element.rb, line 141
def test_bin_iterate
    b1 = __create_bin("foo")
    b2 = __create_bin("bar")
    res1 = {
        b1 => 0,
        b2 => 0
    }
    res2 = {
        b1 => 0,
        b2 => 0
    }
    [ b1, b2 ].each do |bin|
        assert_raises(ArgumentError) { bin.on_pre_iterate }
        bin.on_pre_iterate { |bin| res1[bin] += 1 } 
        assert_raises(RuntimeError) { bin.on_pre_iterate {} }
        assert_raises(ArgumentError) { bin.on_post_iterate }
        bin.on_post_iterate { |bin| res2[bin] += 1 }
        assert_raises(RuntimeError) { bin.on_post_iterate {} }
        bin.play
    end
    50.times do |i|
        [ b1, b2 ].each do |bin|
            assert_equal(res1[bin], i)
            assert_equal(res2[bin], i)
            bin.iterate
        end
    end
    [ b1, b2 ].each do |bin| 
        assert_equal(50, res1[bin])
        assert_equal(50, res2[bin])
        bin.stop
    end
end
test_element() click to toggle source
# File gstreamer/tests/tc_element.rb, line 23
def test_element
    assert_instance_of(Gst::Element, e  = Gst::ElementFactory.make("fakesrc"))
    assert_instance_of(Gst::Element, e2 = Gst::ElementFactory.make("fakesrc", "plok"))
    e.test(self); e2.test(self)
    # Test states 
    state  = Struct.new("State", :code, :get, :set)
    states = [
            state.new(Gst::Element::STATE_READY  , "e.ready?",   "e.ready"),
            state.new(Gst::Element::STATE_PLAYING, "e.playing?", "e.play" ),
            state.new(Gst::Element::STATE_PAUSED , "e.paused?",  "e.pause"),
            state.new(Gst::Element::STATE_NULL   , "e.stopped?", "e.stop" )
    ]       
    valid_codes = [ 
        Gst::Element::STATE_FAILURE,
        Gst::Element::STATE_SUCCESS,
        Gst::Element::STATE_ASYNC
    ] 
    states.each do |state|
        assert_instance_of(Fixnum, state.code)
        assert_instance_of(Fixnum, code = eval(state.set))
        assert valid_codes.include?(code)
        assert_equal(code, Gst::Element::STATE_SUCCESS)
        assert_instance_of(Fixnum, s = e.state)
        assert_equal(s, state.code)
        assert eval(state.get)
        states.each do | state2|
            next if state.code == state2.code
            assert !eval(state2.get)
        end
    end
    # Test properties
    e.each_property do |key, descr, val|
        assert_instance_of(String, key)
        assert_instance_of(String, descr)
        assert_equal(e.get_property(key), val)
        #assert_equal(eval("e.#{key}"), val)
    end
    assert_raises(ArgumentError) do 
        e.get_property("does_not_exist")
    end
    assert_instance_of(String, n = e.get_property("name"))
    assert_equal(e.set_property("name", "foo"), e)
    assert_equal(e.get_property("name"), "foo")
    assert_equal(e.name = n, n)
end
test_elementfactory() click to toggle source
# File gstreamer/tests/tc_element.rb, line 68
def test_elementfactory
    assert_instance_of(Gst::ElementFactory, f = Gst::ElementFactory.find("fakesrc"))
    f.test(self)
    # Test unique auto-generated element names
    a = Array.new
    10.times { a.push(Gst::ElementFactory.make("fakesrc")) }
    a.each { |e| assert_instance_of(Gst::Element, e) }
    assert_nil a.collect { |e| e.name }.uniq! 
end
test_pipeline() click to toggle source
# File gstreamer/tests/tc_element.rb, line 77
def test_pipeline
    assert_instance_of(Gst::Pipeline, p = Gst::Pipeline.new("my pipeline"))
    # Test the pipeline as a Gst::Bin (Gst::Pipeline does not have a #test method)
    p.test(self)
    # Test unique auto-generated pipelines names
    a = Array.new
    10.times { a.push(Gst::Pipeline.new) }
    a.each { |e| assert_instance_of(Gst::Pipeline, e) }
    assert_nil a.collect { |e| e.name }.uniq! 
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.