ruby-libvirt-catphish 0.7.1

data/tests/test_interface.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/ruby
+
+# Test the interface methods the bindings support
+
+$: << File.dirname(__FILE__)
+
+require 'libvirt'
+require 'test_utils.rb'
+
+set_test_object("interface")
+
+conn = Libvirt::open("qemu:///system")
+
+# test setup
+begin
+  `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test`
+  `brctl delbr rb-libvirt-test >& /dev/null`
+rescue
+end
+
+# TESTGROUP: iface.undefine
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(newiface, "undefine", 1)
+
+expect_success(newiface, "no args", "undefine")
+
+# TESTGROUP: iface.create
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(newiface, "create", 1, 2)
+expect_invalid_arg_type(newiface, "create", 'foo')
+
+#expect_success(newiface, "no args", "create")
+
+#expect_fail(newiface, Libvirt::Error, "on already running interface", "create")
+
+#newiface.destroy
+newiface.undefine
+
+# TESTGROUP: iface.destroy
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(newiface, "destroy", 1, 2)
+expect_invalid_arg_type(newiface, "destroy", 'foo')
+
+#expect_success(newiface, "no args", "destroy")
+
+newiface.undefine
+
+# TESTGROUP: iface.active?
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(newiface, "active?", 1)
+
+expect_success(newiface, "no args", "active?") {|x| x == false}
+
+#newiface.create
+#expect_success(newiface, "no args", "active?") {|x| x == true}
+
+#newiface.destroy
+newiface.undefine
+
+# TESTGROUP: iface.name
+newiface = conn.define_interface_xml($new_interface_xml)
+
+expect_too_many_args(newiface, "name", 1)
+
+expect_success(newiface, "no args", "name") {|x| x == "rb-libvirt-test"}
+
+newiface.undefine
+
+# TESTGROUP: iface.mac
+testiface = find_valid_iface(conn)
+if not testiface.nil?
+  expect_too_many_args(testiface, "mac", 1)
+
+  expect_success(testiface, "no args", "mac")
+end
+
+# TESTGROUP: iface.xml_desc
+testiface = find_valid_iface(conn)
+if not testiface.nil?
+  expect_too_many_args(testiface, "xml_desc", 1, 2)
+  expect_invalid_arg_type(testiface, "xml_desc", "foo")
+  expect_success(testiface, "no args", "xml_desc")
+end
+
+# TESTGROUP: iface.free
+newiface = conn.define_interface_xml($new_interface_xml)
+newiface.undefine
+expect_too_many_args(newiface, "free", 1)
+
+expect_success(newiface, "no args", "free")
+
+# END TESTS
+
+conn.close
+
+finish_tests

data/tests/test_network.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/ruby
+
+# Test the network methods the bindings support
+
+$: << File.dirname(__FILE__)
+
+require 'libvirt'
+require 'test_utils.rb'
+
+set_test_object("network")
+
+conn = Libvirt::open("qemu:///system")
+
+cleanup_test_network(conn)
+
+# TESTGROUP: net.undefine
+newnet = conn.define_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "undefine", 1)
+
+expect_success(newnet, "no args", "undefine")
+
+# TESTGROUP: net.create
+newnet = conn.define_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "create", 1)
+
+expect_success(newnet, "no args", "create")
+
+expect_fail(newnet, Libvirt::Error, "on already running network", "create")
+
+newnet.destroy
+newnet.undefine
+
+# TESTGROUP: net.update
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_few_args(newnet, "update", 1)
+
+command = Libvirt::Network::NETWORK_UPDATE_COMMAND_ADD_LAST
+section = Libvirt::Network::NETWORK_SECTION_IP_DHCP_HOST
+flags   = Libvirt::Network::NETWORK_UPDATE_AFFECT_CURRENT
+expect_success(newnet, "dhcp ip", "update",
+               command, section, -1, $new_network_dhcp_ip, flags)
+
+newnet.destroy
+
+# TESTGROUP: net.destroy
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "destroy", 1)
+
+expect_success(newnet, "no args", "destroy")
+
+# TESTGROUP: net.name
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "name", 1)
+
+expect_success(newnet, "no args", "name") {|x| x == "rb-libvirt-test"}
+
+newnet.destroy
+
+# TESTGROUP: net.uuid
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "uuid", 1)
+
+expect_success(newnet, "no args", "uuid") {|x| x == $NETWORK_UUID}
+
+newnet.destroy
+
+# TESTGROUP: net.xml_desc
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "xml_desc", 1, 2)
+expect_invalid_arg_type(newnet, "xml_desc", "foo")
+
+expect_success(newnet, "no args", "xml_desc")
+
+newnet.destroy
+
+# TESTGROUP: net.bridge_name
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "bridge_name", 1)
+
+expect_success(newnet, "no args", "bridge_name") {|x| x == "rubybr0"}
+
+newnet.destroy
+
+# TESTGROUP: net.autostart?
+newnet = conn.define_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "autostart?", 1)
+
+expect_success(newnet, "no args", "autostart?") {|x| x == false}
+
+newnet.autostart = true
+
+expect_success(newnet, "no args", "autostart?") {|x| x == true}
+
+newnet.undefine
+
+# TESTGROUP: net.autostart=
+newnet = conn.define_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "autostart=", 1, 2)
+expect_invalid_arg_type(newnet, "autostart=", 'foo')
+expect_invalid_arg_type(newnet, "autostart=", nil)
+expect_invalid_arg_type(newnet, "autostart=", 1234)
+
+expect_success(newnet, "boolean arg", "autostart=", true)
+if not newnet.autostart?
+  puts_fail "network.autostart= did not set autostart to true"
+else
+  puts_ok "network.autostart= set autostart to true"
+end
+
+expect_success(newnet, "boolean arg", "autostart=", false)
+if newnet.autostart?
+  puts_fail "network.autostart= did not set autostart to false"
+else
+  puts_ok "network.autostart= set autostart to false"
+end
+
+newnet.undefine
+
+# TESTGROUP: net.free
+newnet = conn.define_network_xml($new_net_xml)
+newnet.undefine
+expect_too_many_args(newnet, "free", 1)
+
+expect_success(newnet, "no args", "free")
+
+# TESTGROUP: net.active?
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "active?", 1)
+
+expect_success(newnet, "no args", "active?") {|x| x == true}
+
+newnet.destroy
+
+newnet = conn.define_network_xml($new_net_xml)
+
+expect_success(newnet, "no args", "active?") {|x| x == false}
+
+newnet.create
+
+expect_success(newnet, "no args", "active?") {|x| x == true}
+
+newnet.destroy
+newnet.undefine
+
+# TESTGROUP: net.persistent?
+newnet = conn.create_network_xml($new_net_xml)
+
+expect_too_many_args(newnet, "persistent?", 1)
+
+expect_success(newnet, "no args", "persistent?") {|x| x == false}
+
+newnet.destroy
+
+newnet = conn.define_network_xml($new_net_xml)
+
+expect_success(newnet, "no args", "persistent?") {|x| x == true}
+
+newnet.undefine
+
+# END TESTS
+
+conn.close
+
+finish_tests

data/tests/test_nodedevice.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby
+
+# Test the nodedevice methods the bindings support
+
+$: << File.dirname(__FILE__)
+
+require 'libvirt'
+require 'test_utils.rb'
+
+set_test_object("nodedevice")
+
+conn = Libvirt::open(URI)
+
+# TESTGROUP: nodedevice.name
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "name", 1)
+expect_success(testnode, "no args", "name")
+
+# TESTGROUP: nodedevice.parent
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "parent", 1)
+expect_success(testnode, "no args", "parent")
+
+# TESTGROUP: nodedevice.num_of_caps
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "num_of_caps", 1)
+expect_success(testnode, "no args", "num_of_caps")
+
+# TESTGROUP: nodedevice.list_caps
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "list_caps", 1)
+expect_success(testnode, "no args", "list_caps")
+
+# TESTGROUP: nodedevice.xml_desc
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "xml_desc", 1, 2)
+expect_invalid_arg_type(testnode, "xml_desc", 'foo')
+expect_success(testnode, "no args", "xml_desc")
+
+# TESTGROUP: nodedevice.detach
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "detach", 1, 2, 3)
+expect_invalid_arg_type(testnode, "detach", 1)
+expect_invalid_arg_type(testnode, "detach", [])
+expect_invalid_arg_type(testnode, "detach", {})
+expect_invalid_arg_type(testnode, "detach", nil, 'foo')
+expect_invalid_arg_type(testnode, "detach", nil, [])
+expect_invalid_arg_type(testnode, "detach", nil, {})
+
+#expect_success(testnode, "no args", "detach")
+
+# TESTGROUP: nodedevice.reattach
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "reattach", 1)
+
+#expect_success(testnode, "no args", "reattach")
+
+# TESTGROUP: nodedevice.reset
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "reset", 1)
+
+#expect_success(testnode, "no args", "reset")
+
+# TESTGROUP: nodedevice.destroy
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "destroy", 1)
+
+#expect_success(testnode, "no args", "destroy")
+
+# TESTGROUP: nodedevice.free
+testnode = conn.lookup_nodedevice_by_name(conn.list_nodedevices[0])
+
+expect_too_many_args(testnode, "free", 1)
+
+expect_success(testnode, "no args", "free")
+
+# END TESTS
+
+conn.close
+
+finish_tests

data/tests/test_nwfilter.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/ruby
+
+# Test the nwfilter methods the bindings support
+
+$: << File.dirname(__FILE__)
+
+require 'libvirt'
+require 'test_utils.rb'
+
+set_test_object("nwfilter")
+
+conn = Libvirt::open("qemu:///system")
+
+# TESTGROUP: nwfilter.undefine
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+
+expect_too_many_args(newnw, "undefine", 1)
+
+expect_success(newnw, "no args", "undefine")
+
+# TESTGROUP: nwfilter.name
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+
+expect_too_many_args(newnw, "name", 1)
+
+expect_success(newnw, "no args", "name") {|x| x == "rb-libvirt-test"}
+
+newnw.undefine
+
+# TESTGROUP: nwfilter.uuid
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+
+expect_too_many_args(newnw, "uuid", 1)
+
+expect_success(newnw, "no args", "uuid") {|x| x == $NWFILTER_UUID}
+
+newnw.undefine
+
+# TESTGROUP: nwfilter.xml_desc
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+
+expect_too_many_args(newnw, "xml_desc", 1, 2)
+expect_invalid_arg_type(newnw, "xml_desc", "foo")
+
+expect_success(newnw, "no args", "xml_desc")
+
+newnw.undefine
+
+# TESTGROUP: nwfilter.free
+newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+newnw.undefine
+expect_too_many_args(newnw, "free", 1)
+
+expect_success(newnw, "no args", "free")
+
+# END TESTS
+
+conn.close
+
+finish_tests

data/tests/test_open.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/ruby
+
+# Test the open calls that the bindings support
+
+$: << File.dirname(__FILE__)
+
+require 'libvirt'
+require 'test_utils.rb'
+
+set_test_object("Libvirt")
+
+def expect_connect_error(func, args)
+  expect_fail(Libvirt, Libvirt::ConnectionError, "invalid driver", func, *args)
+end
+
+# TESTGROUP: Libvirt::version
+expect_too_many_args(Libvirt, "version", "test", 1)
+expect_invalid_arg_type(Libvirt, "version", 1)
+expect_success(Libvirt, "no args", "version") {|x| x.class == Array and x.length == 2}
+expect_success(Libvirt, "nil arg", "version", nil) {|x| x.class == Array and x.length == 2}
+expect_success(Libvirt, "Test arg", "version", "Test") {|x| x.class == Array and x.length == 2}
+
+# TESTGROUP: Libvirt::open
+expect_too_many_args(Libvirt, "open", URI, 1)
+expect_connect_error("open", "foo:///system")
+conn = expect_success(Libvirt, "no args", "open") {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, URI, "open", URI) {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, "nil arg", "open", nil) {|x| x.class == Libvirt::Connect }
+conn.close
+
+# TESTGROUP: Libvirt::open_read_only
+expect_too_many_args(Libvirt, "open_read_only", URI, 1)
+expect_connect_error("open_read_only", "foo:///system")
+conn = expect_success(Libvirt, "no args", "open_read_only") {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, URI, "open_read_only", URI) {|x| x.class == Libvirt::Connect }
+conn.close
+conn = expect_success(Libvirt, "nil arg", "open_read_only", nil) {|x| x.class == Libvirt::Connect }
+conn.close
+
+# TESTGROUP: Libvirt::open_auth
+expect_too_many_args(Libvirt, "open_auth", URI, [], "hello there", 1, 2)
+expect_connect_error("open_auth", "foo:///system")
+expect_invalid_arg_type(Libvirt, "open_auth", 1)
+expect_invalid_arg_type(Libvirt, "open_auth", URI, [], "hello", "foo")
+
+conn = expect_success(Libvirt, "no args", "open_auth")  {|x| x.class == Libvirt::Connect }
+conn.close
+
+conn = expect_success(Libvirt, "uri arg", "open_auth", URI) {|x| x.class == Libvirt::Connect }
+conn.close
+
+conn = expect_success(Libvirt, "uri and empty cred args", "open_auth", URI, []) {|x| x.class == Libvirt::Connect }
+conn.close
+
+conn = expect_success(Libvirt, "uri and full cred args", "open_auth", URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE]) {|x| x.class == Libvirt::Connect }
+conn.close
+
+conn = expect_success(Libvirt, "uri, full cred, and user args", "open_auth", URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello") {|x| x.class == Libvirt::Connect }
+conn.close
+
+# equivalent to expect_invalid_arg_type
+begin
+  conn = Libvirt::open_auth(URI, {}) do |cred|
+  end
+rescue TypeError => e
+  puts_ok "#{$test_object}.open_auth invalid arg type threw #{TypeError.to_s}"
+else
+  puts_fail "#{$test_object}.open_auth invalid arg type expected to throw #{TypeError.to_s}, but threw nothing"
+end
+
+# equivalent to expect_invalid_arg_type
+begin
+  conn = Libvirt::open_auth(URI, 1) do |cred|
+  end
+rescue TypeError => e
+  puts_ok "#{$test_object}.open_auth invalid arg type threw #{TypeError.to_s}"
+else
+  puts_fail "#{$test_object}.open_auth invalid arg type expected to throw #{TypeError.to_s}, but threw nothing"
+end
+
+# equivalent to expect_invalid_arg_type
+begin
+  conn = Libvirt::open_auth(URI, 'foo') do |cred|
+  end
+rescue TypeError => e
+  puts_ok "#{$test_object}.open_auth invalid arg type threw #{TypeError.to_s}"
+else
+  puts_fail "#{$test_object}.open_auth invalid arg type expected to throw #{TypeError.to_s}, but threw nothing"
+end
+
+# equivalent to "expect_success"
+begin
+  conn = Libvirt::open_auth(URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello") do |cred|
+    if not cred["userdata"].nil?
+      puts "userdata is #{cred["userdata"]}"
+    end
+    if cred["type"] == Libvirt::CRED_AUTHNAME
+      print "#{cred['prompt']}: "
+      res = gets
+      # strip off the \n
+      res = res[0..-2]
+    elsif cred["type"] == Libvirt::CRED_PASSPHRASE
+      print "#{cred['prompt']}: "
+      res = gets
+      res = res[0..-2]
+    else
+      raise "Unsupported credential #{cred['type']}"
+    end
+    res
+  end
+
+  puts_ok "Libvirt.open_auth uri, creds, userdata, auth block succeeded"
+  conn.close
+rescue NoMethodError
+  puts_skipped "Libvirt.open_auth does not exist"
+rescue => e
+  puts_fail "Libvirt.open_auth uri, creds, userdata, auth block expected to succeed, threw #{e.class.to_s}: #{e.to_s}"
+end
+
+# equivalent to "expect_success"
+begin
+  conn = Libvirt::open_auth(URI) do |cred|
+  end
+
+  puts_ok "Libvirt.open_auth uri, succeeded"
+  conn.close
+rescue NoMethodError
+  puts_skipped "Libvirt.open_auth does not exist"
+rescue => e
+  puts_fail "Libvirt.open_auth uri expected to succeed, threw #{e.class.to_s}: #{e.to_s}"
+end
+
+# equivalent to "expect_success"
+begin
+  conn = Libvirt::open_auth(URI, [Libvirt::CRED_AUTHNAME, Libvirt::CRED_PASSPHRASE], "hello", Libvirt::CONNECT_RO) do |cred|
+    if not cred["userdata"].nil?
+      puts "userdata is #{cred["userdata"]}"
+    end
+    if cred["type"] == Libvirt::CRED_AUTHNAME
+      print "#{cred['prompt']}: "
+      res = gets
+      # strip off the \n
+      res = res[0..-2]
+    elsif cred["type"] == Libvirt::CRED_PASSPHRASE
+      print "#{cred['prompt']}: "
+      res = gets
+      res = res[0..-2]
+    else
+      raise "Unsupported credential #{cred['type']}"
+    end
+    res
+  end
+
+  puts_ok "Libvirt.open_auth uri, creds, userdata, R/O flag, auth block succeeded"
+  conn.close
+rescue NoMethodError
+  puts_skipped "Libvirt.open_auth does not exist"
+rescue => e
+  puts_fail "Libvirt.open_auth uri, creds, userdata, R/O flag, auth block expected to succeed, threw #{e.class.to_s}: #{e.to_s}"
+end
+
+# TESTGROUP: Libvirt::event_invoke_handle_callback
+conn = Libvirt::open(URI)
+
+expect_too_many_args(Libvirt, "event_invoke_handle_callback", 1, 2, 3, 4, 5)
+expect_too_few_args(Libvirt, "event_invoke_handle_callback")
+expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1)
+expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1, 2)
+expect_too_few_args(Libvirt, "event_invoke_handle_callback", 1, 2, 3)
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, 1)
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, [])
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, nil)
+# this is a bit bizarre; I am constructing a bogus hash to pass as the 4th
+# parameter to event_invoke_handle_callback.  In a real situation, I would
+# have been given this hash from libvirt earlier, and just pass it on.  I
+# don't want all of that complexity here, though, so I create the bogus hash.
+# One caveat; the data inside the hash *must* be of type T_DATA, so I pass in
+# a fake conn object just to appease the type checker (so I can test out the
+# other arguments properly)
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", "hello", 1, 1, { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, "hello", 1, { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, "hello", { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, 1, { "libvirt_cb" => "hello", "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_handle_callback", 1, 1, 1, { "libvirt_cb" => conn, "opaque" => "hello" })
+conn.close
+
+# TESTGROUP: Libvirt::event_invoke_timeout_callback
+conn = Libvirt::open(URI)
+
+expect_too_many_args(Libvirt, "event_invoke_timeout_callback", 1, 2, 3)
+expect_too_few_args(Libvirt, "event_invoke_timeout_callback")
+expect_too_few_args(Libvirt, "event_invoke_timeout_callback", 1)
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", 1)
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", [])
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", nil)
+# this is a bit bizarre; I am constructing a bogus hash to pass as the 4th
+# parameter to event_invoke_handle_callback.  In a real situation, I would
+# have been given this hash from libvirt earlier, and just pass it on.  I
+# don't want all of that complexity here, though, so I create the bogus hash.
+# One caveat; the data inside the hash *must* be of type T_DATA, so I pass in
+# a fake conn object just to appease the type checker (so I can test out the
+# other arguments properly)
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", "hello", { "libvirt_cb" => conn, "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", 1, { "libvirt_cb" => "hello", "opaque" => conn })
+expect_invalid_arg_type(Libvirt, "event_invoke_timeout_callback", 1, { "libvirt_cb" => conn, "opaque" => "hello" })
+conn.close
+
+# TESTGROUP: Libvirt::event_register_impl
+expect_too_many_args(Libvirt, "event_register_impl", 1, 2, 3, 4, 5, 6, 7)
+expect_invalid_arg_type(Libvirt, "event_register_impl", 1)
+
+# symbol callbacks
+def virEventAddHandleImpl(fd, events, opaque)
+end
+def virEventUpdateHandleImpl(watch, event)
+end
+def virEventRemoveHandleImpl(handleID)
+end
+def virEventAddTimerImpl(interval, opaque)
+end
+def virEventUpdateTimerImpl(timer, timeout)
+end
+def virEventRemoveTimerImpl(timerID)
+end
+
+# proc callbacks
+virEventAddHandleProc = lambda {|fd, events, opaque|
+}
+virEventUpdateHandleProc = lambda {|watch, event|
+}
+virEventRemoveHandleProc = lambda {|handleID|
+}
+virEventAddTimerProc = lambda {|interval, opaque|
+}
+virEventUpdateTimerProc = lambda {|timer, timeout|
+}
+virEventRemoveTimerProc = lambda {|timerID|
+}
+
+expect_success(Libvirt, "all Symbol callbacks", "event_register_impl", :virEventAddHandleImpl, :virEventUpdateHandleImpl, :virEventRemoveHandleImpl, :virEventAddTimerImpl, :virEventUpdateTimerImpl, :virEventRemoveTimerImpl)
+expect_success(Libvirt, "unregister all callbacks", "event_register_impl", nil, nil, nil, nil, nil, nil)
+expect_success(Libvirt, "all Proc callbacks", "event_register_impl", virEventAddHandleProc, virEventUpdateHandleProc, virEventRemoveHandleProc, virEventAddTimerProc, virEventUpdateTimerProc, virEventRemoveTimerProc)
+expect_success(Libvirt, "unregister all callbacks", "event_register_impl")
+
+# END TESTS
+
+finish_tests