ruby-libvirt 0.8.2 → 0.8.4

data/tests/test_interface.rb

@@ -9,13 +9,15 @@ require 'test_utils.rb'
 
 set_test_object("interface")
 
-conn = Libvirt::open("qemu:///system")
+conn = Libvirt::open(URI)
 
 # test setup
-begin
-  `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test`
-  `brctl delbr rb-libvirt-test >& /dev/null`
-rescue
+if !test_default_uri?
+  begin
+    `rm -f /etc/sysconfig/network-scripts/ifcfg-rb-libvirt-test`
+    `brctl delbr rb-libvirt-test >& /dev/null`
+  rescue
+  end
 end
 
 # TESTGROUP: iface.undefine

data/tests/test_network.rb

@@ -9,7 +9,7 @@ require 'test_utils.rb'
 
 set_test_object("network")
 
-conn = Libvirt::open("qemu:///system")
+conn = Libvirt::open(URI)
 
 cleanup_test_network(conn)
 

data/tests/test_nwfilter.rb

@@ -9,49 +9,59 @@ require 'test_utils.rb'
 
 set_test_object("nwfilter")
 
-conn = Libvirt::open("qemu:///system")
+conn = Libvirt::open(URI)
 
 # TESTGROUP: nwfilter.undefine
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+if !test_default_uri?
+  newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
 
-expect_too_many_args(newnw, "undefine", 1)
+  expect_too_many_args(newnw, "undefine", 1)
 
-expect_success(newnw, "no args", "undefine")
+  expect_success(newnw, "no args", "undefine")
+end
 
 # TESTGROUP: nwfilter.name
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+if !test_default_uri?
+  newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
 
-expect_too_many_args(newnw, "name", 1)
+  expect_too_many_args(newnw, "name", 1)
 
-expect_success(newnw, "no args", "name") {|x| x == "rb-libvirt-test"}
+  expect_success(newnw, "no args", "name") {|x| x == "rb-libvirt-test"}
 
-newnw.undefine
+  newnw.undefine
+end
 
 # TESTGROUP: nwfilter.uuid
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+if !test_default_uri?
+  newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
 
-expect_too_many_args(newnw, "uuid", 1)
+  expect_too_many_args(newnw, "uuid", 1)
 
-expect_success(newnw, "no args", "uuid") {|x| x == $NWFILTER_UUID}
+  expect_success(newnw, "no args", "uuid") {|x| x == $NWFILTER_UUID}
 
-newnw.undefine
+  newnw.undefine
+end
 
 # TESTGROUP: nwfilter.xml_desc
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+if !test_default_uri?
+  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_too_many_args(newnw, "xml_desc", 1, 2)
+  expect_invalid_arg_type(newnw, "xml_desc", "foo")
 
-expect_success(newnw, "no args", "xml_desc")
+  expect_success(newnw, "no args", "xml_desc")
 
-newnw.undefine
+  newnw.undefine
+end
 
 # TESTGROUP: nwfilter.free
-newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
-newnw.undefine
-expect_too_many_args(newnw, "free", 1)
+if !test_default_uri?
+  newnw = conn.define_nwfilter_xml($new_nwfilter_xml)
+  newnw.undefine
+  expect_too_many_args(newnw, "free", 1)
 
-expect_success(newnw, "no args", "free")
+  expect_success(newnw, "no args", "free")
+end
 
 # END TESTS
 

data/tests/test_open.rb

@@ -21,229 +21,241 @@ expect_success(Libvirt, "nil arg", "version", nil) {|x| x.class == Array and x.l
 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
+if !test_default_uri?
+  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
+end
 
 # 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
+if !test_default_uri?
+  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
+end
 
 # 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")
+if !test_default_uri?
+  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, "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 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 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 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
+  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|
+  # 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
-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|
+  # 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
-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|
+  # 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
-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']}"
+  # 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
-    res
+
+    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
 
-  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
 
-# equivalent to "expect_success"
-begin
-  conn = Libvirt::open_auth(URI) do |cred|
+    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
 
-  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"]}"
+  # 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
-    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}"
+    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
 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
+if !test_default_uri?
+  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
+end
 
 # 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
+if !test_default_uri?
+  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
+end
 
 # 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)
+if !test_default_uri?
+  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
+  # 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")
+  # 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
 
 # END TESTS