ruby-libvirt 0.4.0 → 0.5.0

data/ext/libvirt/stream.h

@@ -1,7 +1,9 @@
 #ifndef STREAM_H
 #define STREAM_H
 
-virStreamPtr stream_get(VALUE s);
-void init_stream();
+void ruby_libvirt_stream_init(void);
+
+VALUE ruby_libvirt_stream_new(virStreamPtr s, VALUE conn);
+virStreamPtr ruby_libvirt_stream_get(VALUE s);
 
 #endif

data/tests/test_conn.rb

@@ -7,18 +7,22 @@ $: << File.dirname(__FILE__)
 require 'libvirt'
 require 'test_utils.rb'
 
+set_test_object("connect")
+
+conn = Libvirt::open("qemu:///system")
+
+cleanup_test_domain(conn)
+cleanup_test_network(conn)
+
 # test setup
 begin
   `rm -f /etc/sysconfig/network-scripts/ifcfg-ruby-libvirt-tester`
   `brctl delbr ruby-libvirt-tester >& /dev/null`
 rescue
 end
-`rm -f #{$GUEST_DISK} ; qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
-`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
+`qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
 `rm -rf #{$POOL_PATH}; mkdir #{$POOL_PATH} ; echo $?`
 
-conn = Libvirt::open("qemu:///system")
-
 cpu_xml = <<EOF
 <cpu>
   <arch>x86_64</arch>
@@ -78,35 +82,19 @@ expect_too_many_args(conn, "node_get_info", 1)
 
 expect_success(conn, "no args", "node_get_info")
 
-begin
-  # TESTGROUP: conn.node_free_memory
-  expect_too_many_args(conn, "node_free_memory", 1)
-
-  conn.node_free_memory
-  puts_ok "conn.node_free_memory no args"
-rescue Libvirt::RetrieveError
-  puts_skipped "conn.node_free_memory not supported on this host"
-rescue NoMethodError
-  puts_skipped "conn.node_free_memory does not exist"
-end
+# TESTGROUP: conn.node_free_memory
+expect_too_many_args(conn, "node_free_memory", 1)
 
-begin
-  # TESTGROUP: conn.node_cells_free_memory
-  expect_too_many_args(conn, "node_cells_free_memory", 1, 2, 3)
-  expect_invalid_arg_type(conn, "node_cells_free_memory", 'start')
-  expect_invalid_arg_type(conn, "node_cells_free_memory", 0, 'end')
-
-  cell_mem = conn.node_cells_free_memory
-  puts_ok "conn.node_cells_free_memory no args = "
-  cell_mem = conn.node_cells_free_memory(0)
-  puts_ok "conn.node_cells_free_memory(0) = "
-  cell_mem = conn.node_cells_free_memory(0, 1)
-  puts_ok "conn.node_cells_free_memory(0, 1) = "
-rescue Libvirt::RetrieveError
-  puts_skipped "conn.node_cells_free_memory not supported on this host"
-rescue NoMethodError
-  puts_skipped "conn.node_cells_free_memory does not exist"
-end
+expect_success(conn, "no args", "node_free_memory")
+
+# TESTGROUP: conn.node_cells_free_memory
+expect_too_many_args(conn, "node_cells_free_memory", 1, 2, 3)
+expect_invalid_arg_type(conn, "node_cells_free_memory", 'start')
+expect_invalid_arg_type(conn, "node_cells_free_memory", 0, 'end')
+
+expect_success(conn, "no args", "node_cells_free_memory")
+expect_success(conn, "start cell", "node_cells_free_memory", 0)
+expect_success(conn, "start cell and max cells", "node_cells_free_memory", 0, 1)
 
 # TESTGROUP: conn.node_get_security_model
 expect_too_many_args(conn, "node_get_security_model", 1)
@@ -136,7 +124,7 @@ expect_success(conn, "CPU XML", "compare_cpu", cpu_xml)
 expect_too_many_args(conn, "baseline_cpu", 1, 2, 3)
 expect_too_few_args(conn, "baseline_cpu")
 expect_invalid_arg_type(conn, "baseline_cpu", 1)
-expect_invalid_arg_type(conn, "baseline_cpu", [], "foo")
+expect_invalid_arg_type(conn, "baseline_cpu", [cpu_xml], "foo")
 expect_fail(conn, ArgumentError, "empty array", "baseline_cpu", [])
 expect_success(conn, "CPU XML", "baseline_cpu", [cpu_xml])
 
@@ -144,8 +132,8 @@ expect_success(conn, "CPU XML", "baseline_cpu", [cpu_xml])
 dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
 }
 
-def dom_event_callback_symbol(conn, dom, event, detail, opaque)
-end
+# def dom_event_callback_symbol(conn, dom, event, detail, opaque)
+# end
 
 expect_too_many_args(conn, "domain_event_register_any", 1, 2, 3, 4, 5)
 expect_too_few_args(conn, "domain_event_register_any")
@@ -155,58 +143,58 @@ expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOM
 expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, 1)
 expect_fail(conn, ArgumentError, "invalid event ID", "domain_event_register_any", 456789, dom_event_callback_proc)
 
-callbackID = expect_success(conn, "eventID and proc", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc)
-conn.domain_event_deregister_any(callbackID)
+# callbackID = expect_success(conn, "eventID and proc", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc)
+# conn.domain_event_deregister_any(callbackID)
 
-callbackID = expect_success(conn, "eventID and symbol", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, :dom_event_callback_symbol)
-conn.domain_event_deregister_any(callbackID)
+# callbackID = expect_success(conn, "eventID and symbol", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, :dom_event_callback_symbol)
+# conn.domain_event_deregister_any(callbackID)
 
-callbackID = expect_success(conn, "eventID, proc, nil domain", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil)
-conn.domain_event_deregister_any(callbackID)
+# callbackID = expect_success(conn, "eventID, proc, nil domain", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil)
+# conn.domain_event_deregister_any(callbackID)
 
-callbackID = expect_success(conn, "eventID, proc, nil domain, opaque", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil, "opaque user data")
-conn.domain_event_deregister_any(callbackID)
+# callbackID = expect_success(conn, "eventID, proc, nil domain, opaque", "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc, nil, "opaque user data")
+# conn.domain_event_deregister_any(callbackID)
 
-# TESTGROUP: conn.domain_event_deregister_any
-dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
-}
+# # TESTGROUP: conn.domain_event_deregister_any
+# dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
+# }
 
-callbackID = conn.domain_event_register_any(Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc)
+# callbackID = conn.domain_event_register_any(Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, dom_event_callback_proc)
 
 expect_too_many_args(conn, "domain_event_deregister_any", 1, 2)
 expect_too_few_args(conn, "domain_event_deregister_any")
 expect_invalid_arg_type(conn, "domain_event_deregister_any", "hello")
 
-expect_success(conn, "callbackID", "domain_event_deregister_any", callbackID)
+# expect_success(conn, "callbackID", "domain_event_deregister_any", callbackID)
 
 # TESTGROUP: conn.domain_event_register
-dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
-}
+# dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
+# }
 
-def dom_event_callback_symbol(conn, dom, event, detail, opaque)
-end
+# def dom_event_callback_symbol(conn, dom, event, detail, opaque)
+# end
 
 expect_too_many_args(conn, "domain_event_register", 1, 2, 3)
 expect_too_few_args(conn, "domain_event_register")
 expect_invalid_arg_type(conn, "domain_event_register", "hello")
 
-expect_success(conn, "proc", "domain_event_register", dom_event_callback_proc)
-conn.domain_event_deregister
+# expect_success(conn, "proc", "domain_event_register", dom_event_callback_proc)
+# conn.domain_event_deregister
 
-expect_success(conn, "symbol", "domain_event_register", :dom_event_callback_symbol)
-conn.domain_event_deregister
+# expect_success(conn, "symbol", "domain_event_register", :dom_event_callback_symbol)
+# conn.domain_event_deregister
 
-expect_success(conn, "proc and opaque", "domain_event_register", dom_event_callback_proc, "opaque user data")
-conn.domain_event_deregister
+# expect_success(conn, "proc and opaque", "domain_event_register", dom_event_callback_proc, "opaque user data")
+# conn.domain_event_deregister
 
-# TESTGROUP: conn.domain_event_deregister
-dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
-}
+# # TESTGROUP: conn.domain_event_deregister
+# dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
+# }
 
-conn.domain_event_register(dom_event_callback_proc)
+# conn.domain_event_register(dom_event_callback_proc)
 
 expect_too_many_args(conn, "domain_event_deregister", 1)
-expect_success(conn, "no args", "domain_event_deregister")
+# expect_success(conn, "no args", "domain_event_deregister")
 
 # TESTGROUP: conn.num_of_domains
 expect_too_many_args(conn, "num_of_domains", 1)
@@ -216,6 +204,13 @@ expect_success(conn, "no args", "num_of_domains")
 expect_too_many_args(conn, "list_domains", 1)
 expect_success(conn, "no args", "list_domains")
 
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_success(conn, "no args", "list_domains")
+
+newdom.destroy
+
 # TESTGROUP: conn.num_of_defined_domains
 expect_too_many_args(conn, "num_of_defined_domains", 1)
 expect_success(conn, "no args", "num_of_defined_domains")
@@ -372,10 +367,9 @@ expect_too_few_args(conn, "lookup_interface_by_mac")
 expect_invalid_arg_type(conn, "lookup_interface_by_mac", 1)
 expect_fail(conn, Libvirt::RetrieveError, "non-existent mac arg", "lookup_interface_by_mac", "foobarbazsucker")
 
-testiface = find_valid_iface(conn)
-if not testiface.nil?
-  expect_success(conn, "name arg", "lookup_interface_by_mac", testiface.mac) {|x| x.mac == testiface.mac}
-end
+# FIXME: we can't look up an interface by MAC address on an inactive interface,
+# but we also can't start up the interface without a /etc/sysconfig file.
+#expect_success(conn, "mac arg", "lookup_interface_by_mac", $NEW_INTERFACE_MAC) {|x| x.mac == $NEW_INTERFACE_MAC}
 
 newiface.undefine
 
@@ -668,6 +662,159 @@ expect_invalid_arg_type(conn, "sys_info", "foo")
 
 expect_success(conn, "system info", "sys_info")
 
+# TESTGROUP: conn.interface_change_begin
+expect_too_many_args(conn, "interface_change_begin", 1, 2)
+expect_invalid_arg_type(conn, "interface_change_begin", 'hello')
+
+expect_success(conn, "interface change begin", "interface_change_begin")
+
+conn.interface_change_rollback
+
+# TESTGROUP: conn.interface_change_commit
+expect_too_many_args(conn, "interface_change_commit", 1, 2)
+expect_invalid_arg_type(conn, "interface_change_commit", 'foo')
+
+# FIXME: libvirt throws an error on commit with no changes.  What changes can
+# we do here?
+#expect_success(conn, "interface change commit", "interface_change_commit")
+
+# TESTGROUP: conn.interface_change_rollback
+conn.interface_change_begin
+
+expect_too_many_args(conn, "interface_change_rollback", 1, 2)
+expect_invalid_arg_type(conn, "interface_change_rollback", 'foo')
+
+expect_success(conn, "interface change rollback", "interface_change_rollback")
+
+# TESTGROUP: conn.node_cpu_stats
+expect_too_many_args(conn, "node_cpu_stats", 1, 2, 3)
+expect_invalid_arg_type(conn, "node_cpu_stats", 'foo')
+expect_invalid_arg_type(conn, "node_cpu_stats", 1, 'bar')
+
+expect_success(conn, "node cpu stats", "node_cpu_stats")
+
+# TESTGROUP: conn.node_memory_stats
+expect_too_many_args(conn, "node_memory_stats", 1, 2, 3)
+expect_invalid_arg_type(conn, "node_memory_stats", 'foo')
+expect_invalid_arg_type(conn, "node_memory_stats", 1, 'bar')
+
+expect_success(conn, "node memory status", "node_memory_stats")
+
+# TESTGROUP: conn.save_image_xml_desc
+newdom = conn.define_domain_xml($new_dom_xml)
+newdom.create
+sleep 1
+newdom.save($GUEST_SAVE)
+
+expect_too_many_args(conn, "save_image_xml_desc", 1, 2, 3)
+expect_too_few_args(conn, "save_image_xml_desc")
+expect_invalid_arg_type(conn, "save_image_xml_desc", nil)
+expect_invalid_arg_type(conn, "save_image_xml_desc", 1)
+expect_invalid_arg_type(conn, "save_image_xml_desc", 'foo', 'bar')
+
+expect_success(conn, "save image path", "save_image_xml_desc", $GUEST_SAVE)
+`rm -f #{$GUEST_SAVE}`
+
+# TESTGROUP: conn.define_save_image_xml
+expect_too_many_args(conn, "define_save_image_xml", 1, 2, 3, 4)
+expect_too_few_args(conn, "define_save_image_xml")
+expect_too_few_args(conn, "define_save_image_xml", 'foo')
+expect_invalid_arg_type(conn, "define_save_image_xml", nil, 'foo')
+expect_invalid_arg_type(conn, "define_save_image_xml", 1, 'foo')
+expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', nil)
+expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', 1)
+expect_invalid_arg_type(conn, "define_save_image_xml", 'foo', 'bar', 'baz')
+
+# TESTGROUP: conn.alive?
+expect_too_many_args(conn, "alive?", 1)
+
+expect_success(conn, "alive connection", "alive?") {|x| x == true}
+
+# TESTGROUP: conn.list_all_nwfilters
+expect_too_many_args(conn, "list_all_nwfilters", 1, 2)
+expect_invalid_arg_type(conn, "list_all_nwfilters", "foo")
+
+expect_success(conn, "no args", "list_all_nwfilters")
+
+# TESTGROUP: conn.list_all_storage_pools
+expect_too_many_args(conn, "list_all_storage_pools", 1, 2)
+expect_invalid_arg_type(conn, "list_all_storage_pools", "foo")
+
+expect_success(conn, "no args", "list_all_storage_pools")
+
+# TESTGROUP: conn.list_all_nodedevices
+expect_too_many_args(conn, "list_all_nodedevices", 1, 2)
+expect_invalid_arg_type(conn, "list_all_nodedevices", "foo")
+
+expect_success(conn, "no args", "list_all_nodedevices")
+
+# TESTGROUP: conn.list_all_secrets
+expect_too_many_args(conn, "list_all_secrets", 1, 2)
+expect_invalid_arg_type(conn, "list_all_secrets", "foo")
+
+expect_success(conn, "no args", "list_all_secrets")
+
+# TESTGROUP: conn.list_all_interfaces
+expect_too_many_args(conn, "list_all_interfaces", 1, 2)
+expect_invalid_arg_type(conn, "list_all_interfaces", "foo")
+
+expect_success(conn, "no args", "list_all_interfaces")
+
+# TESTGROUP: conn.list_all_networks
+expect_too_many_args(conn, "list_all_networks", 1, 2)
+expect_invalid_arg_type(conn, "list_all_networks", "foo")
+
+expect_success(conn, "no args", "list_all_networks")
+
+# TESTGROUP: conn.list_all_domains
+expect_too_many_args(conn, "list_all_domains", 1, 2)
+expect_invalid_arg_type(conn, "list_all_domains", "foo")
+
+expect_success(conn, "no args", "list_all_domains")
+
+# TESTGROUP: conn.set_keepalive
+expect_too_many_args(conn, "set_keepalive", 1, 2, 3, 4)
+expect_too_few_args(conn, "set_keepalive")
+expect_too_few_args(conn, "set_keepalive", 1)
+expect_invalid_arg_type(conn, "set_keepalive", 'foo', 0)
+expect_invalid_arg_type(conn, "set_keepalive", 0, 'foo')
+
+# FIXME: somehow we need an event loop implementation for this to work
+#expect_success(conn, "interval and count", "set_keepalive", 1, 10)
+
+# TESTGROUP: conn.node_suspend_for_duration
+expect_too_many_args(conn, "node_suspend_for_duration", 1, 2, 3, 4)
+expect_too_few_args(conn, "node_suspend_for_duration")
+expect_too_few_args(conn, "node_suspend_for_duration", 1)
+expect_invalid_arg_type(conn, "node_suspend_for_duration", 'foo', 1)
+expect_invalid_arg_type(conn, "node_suspend_for_duration", 1, 'foo')
+expect_invalid_arg_type(conn, "node_suspend_for_duration", 1, 2, 'foo')
+
+# TESTGROUP: conn.node_memory_parameters
+expect_too_many_args(conn, "node_memory_parameters", 1, 2)
+expect_invalid_arg_type(conn, "node_memory_parameters", 'foo')
+
+expect_success(conn, "no args", "node_memory_parameters")
+
+# TESTGROUP: conn.node_memory_paramters=
+expect_too_many_args(conn, "node_memory_parameters=", 1, 2)
+expect_invalid_arg_type(conn, "node_memory_parameters=", nil)
+expect_invalid_arg_type(conn, "node_memory_parameters=", ['foo', 0])
+expect_invalid_arg_type(conn, "node_memory_parameters=", [{}, 'foo'])
+
+# TESTGROUP: conn.keepalive=
+expect_too_many_args(conn, "keepalive=", 1, 2)
+expect_too_few_args(conn, "keepalive=", [])
+expect_too_few_args(conn, "keepalive=", [1])
+expect_invalid_arg_type(conn, "keepalive=", 1)
+expect_invalid_arg_type(conn, "keepalive=", ['foo', 1])
+expect_invalid_arg_type(conn, "keepalive=", [1, 'foo'])
+
+# FIXME: somehow we need an event loop implementation for this to work
+#expect_success(conn, "interval and count", "keepalive=", 1, 10)
+
+# END TESTS
+
 conn.close
 
 finish_tests

data/tests/test_domain.rb

@@ -11,20 +11,14 @@ $: << File.dirname(__FILE__)
 require 'libvirt'
 require 'test_utils.rb'
 
+set_test_object("domain")
+
 conn = Libvirt::open("qemu:///system")
 
-# initial cleanup for previous runs
-begin
-  olddom = conn.lookup_domain_by_name("ruby-libvirt-tester")
-  olddom.destroy
-  olddom.undefine
-rescue
-  # in case we didn't find it, don't do anything
-end
+cleanup_test_domain(conn)
 
 # setup for later tests
-`rm -f #{$GUEST_DISK} ; qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
-`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
+`qemu-img create -f qcow2 #{$GUEST_DISK} 5G`
 
 new_hostdev_xml = <<EOF
 <hostdev mode='subsystem' type='pci' managed='yes'>
@@ -36,6 +30,145 @@ EOF
 
 # start tests
 
+# TESTGROUP: dom.migrate_max_speed
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "migrate_max_speed", 1, 2)
+expect_invalid_arg_type(newdom, "migrate_max_speed", 'foo')
+expect_invalid_arg_type(newdom, "migrate_max_speed", [])
+expect_invalid_arg_type(newdom, "migrate_max_speed", {})
+
+expect_success(newdom, "no args", "migrate_max_speed")
+
+newdom.destroy
+
+# TESTGROUP: dom.reset
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "reset", 1, 2)
+expect_invalid_arg_type(newdom, "reset", 'foo')
+expect_invalid_arg_type(newdom, "reset", [])
+expect_invalid_arg_type(newdom, "reset", {})
+
+expect_success(newdom, "no args", "reset")
+
+newdom.destroy
+
+# TESTGROUP: dom.hostname
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "hostname", 1, 2)
+expect_invalid_arg_type(newdom, "hostname", 'foo')
+expect_invalid_arg_type(newdom, "hostname", [])
+expect_invalid_arg_type(newdom, "hostname", {})
+
+# FIXME: spits an error "this function is not supported by the connection driver"
+#expect_success(newdom, "no args", "hostname")
+
+newdom.destroy
+
+# TESTGROUP: dom.metadata
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "metadata", 1, 2, 3, 4)
+expect_too_few_args(newdom, "metadata")
+expect_invalid_arg_type(newdom, "metadata", 'foo')
+expect_invalid_arg_type(newdom, "metadata", nil)
+expect_invalid_arg_type(newdom, "metadata", [])
+expect_invalid_arg_type(newdom, "metadata", {})
+expect_invalid_arg_type(newdom, "metadata", 1, 1)
+expect_invalid_arg_type(newdom, "metadata", 1, 'foo', 'bar')
+
+expect_success(newdom, "no args", "metadata", Libvirt::Domain::METADATA_DESCRIPTION) {|x| x == "Ruby Libvirt Tester"}
+
+newdom.destroy
+
+# TESTGROUP: dom.metadata=
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "metadata=", 1, 2, 3, 4, 5, 6)
+expect_too_few_args(newdom, "metadata=")
+expect_too_few_args(newdom, "metadata=", [1])
+expect_invalid_arg_type(newdom, "metadata=", 1)
+expect_invalid_arg_type(newdom, "metadata=", 'foo')
+expect_invalid_arg_type(newdom, "metadata=", nil)
+expect_invalid_arg_type(newdom, "metadata=", {})
+expect_invalid_arg_type(newdom, "metadata=", ['foo', nil])
+expect_invalid_arg_type(newdom, "metadata=", [nil, nil])
+expect_invalid_arg_type(newdom, "metadata=", [[], nil])
+expect_invalid_arg_type(newdom, "metadata=", [{}, nil])
+expect_invalid_arg_type(newdom, "metadata=", [1, 1])
+expect_invalid_arg_type(newdom, "metadata=", [1, []])
+expect_invalid_arg_type(newdom, "metadata=", [1, {}])
+
+expect_success(newdom, "no args", "metadata=", [Libvirt::Domain::METADATA_DESCRIPTION, 'foo'])
+expect_success(newdom, "no args", "metadata=", [Libvirt::Domain::METADATA_DESCRIPTION, 'foo', nil, nil, 0])
+
+expect_success(newdom, "no args", "metadata", Libvirt::Domain::METADATA_DESCRIPTION) {|x| x == "foo"}
+
+newdom.destroy
+
+# TESTGROUP: dom.updated?
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "updated?", 1)
+
+expect_success(newdom, "no args", "updated?")
+
+newdom.destroy
+
+# TESTGROUP: dom.inject_nmi
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "inject_nmi", 1, 2)
+expect_invalid_arg_type(newdom, "inject_nmi", 'foo')
+
+expect_success(newdom, "no args", "inject_nmi")
+
+newdom.destroy
+
+# TESTGROUP: dom.control_info
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "control_info", 1, 2)
+expect_invalid_arg_type(newdom, "control_info", 'foo')
+
+expect_success(newdom, "no args", "control_info")
+
+newdom.destroy
+
+# TESTGROUP: dom.send_key
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 30
+
+expect_too_many_args(newdom, "send_key", 1, 2, 3, 4)
+expect_too_few_args(newdom, "send_key")
+expect_too_few_args(newdom, "send_key", 1)
+expect_too_few_args(newdom, "send_key", 1, 2)
+expect_invalid_arg_type(newdom, "send_key", nil, 0, [])
+expect_invalid_arg_type(newdom, "send_key", nil, 0, [1])
+expect_invalid_arg_type(newdom, "send_key", 'foo', 0, [])
+expect_invalid_arg_type(newdom, "send_key", 0, nil, [])
+expect_invalid_arg_type(newdom, "send_key", 0, 'foo', [])
+expect_invalid_arg_type(newdom, "send_key", 0, 1, nil)
+expect_invalid_arg_type(newdom, "send_key", 0, 1, 'foo')
+expect_invalid_arg_type(newdom, "send_key", 0, 1, 2)
+expect_invalid_arg_type(newdom, "send_key", nil, 0, [nil])
+expect_invalid_arg_type(newdom, "send_key", nil, 0, ['foo'])
+
+# FIXME: this fails for reasons that are unclear to me
+#expect_success(newdom, "codeset, holdtime, keycodes args", "send_key", 0, 1, [])
+
+newdom.destroy
+
 # TESTGROUP: dom.migrate
 newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
@@ -94,11 +227,60 @@ expect_fail(newdom, Libvirt::Error, "while no migration in progress", "migrate_s
 
 newdom.destroy
 
+# TESTGROUP: dom.migrate2
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+dconn = Libvirt::open("qemu:///system")
+
+expect_too_many_args(newdom, "migrate2", 1, 2, 3, 4, 5, 6, 7)
+expect_too_few_args(newdom, "migrate2")
+expect_fail(newdom, ArgumentError, "invalid connection object", "migrate2", "foo")
+expect_invalid_arg_type(newdom, "migrate2", dconn, 0)
+
+# FIXME: how can we make this work?
+#expect_success(newdom, "conn arg", "migrate2", dconn)
+
+dconn.close
+
+newdom.destroy
+
+# TESTGROUP: dom.migrate_to_uri2
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "migrate_to_uri2", 1, 2, 3, 4, 5, 6, 7)
+expect_invalid_arg_type(newdom, "migrate_to_uri2", 1)
+expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 1)
+expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 1)
+expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 'bar', 'baz')
+expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 'bar', 0, 1)
+expect_invalid_arg_type(newdom, "migrate_to_uri2", "qemu:///system", 'foo', 'bar', 0, 'foo', 'baz')
+
+#expect_success(newdom, "URI arg", "migrate_to_uri2", "qemu://remote/system")
+
+dconn.close
+
+newdom.destroy
+
+# TESTGROUP: dom.migrate_set_max_speed
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "migrate_set_max_speed", 1, 2, 3)
+expect_too_few_args(newdom, "migrate_set_max_speed")
+expect_invalid_arg_type(newdom, "migrate_set_max_speed", 'foo')
+expect_invalid_arg_type(newdom, "migrate_set_max_speed", 5, 'foo')
+
+#expect_success(newdom, "Bandwidth arg", "migrate_set_max_speed", 5)
+
+newdom.destroy
+
 # TESTGROUP: dom.shutdown
 newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
 
-expect_too_many_args(newdom, "shutdown", 1)
+expect_too_many_args(newdom, "shutdown", 1, 2)
 expect_success(newdom, "no args", "shutdown")
 sleep 1
 newdom.destroy
@@ -109,22 +291,19 @@ sleep 1
 expect_too_many_args(newdom, "reboot", 1, 2)
 expect_invalid_arg_type(newdom, "reboot", "hello")
 
-# Qemu driver doesn't currently support reboot, so this is going to fail
-begin
-  newdom.reboot
-  puts_ok "dom.reboot succeeded"
-rescue Libvirt::Error => e
-  puts_skipped "dom.reboot not supported, skipped"
-end
+expect_success(newdom, "no args", "reboot")
+sleep 1
 
+expect_success(newdom, "flags arg", "reboot", 0)
 sleep 1
+
 newdom.destroy
 
 # TESTGROUP: dom.destroy
 newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
 
-expect_too_many_args(newdom, "destroy", 1)
+expect_too_many_args(newdom, "destroy", 1, 2)
 expect_success(newdom, "no args", "destroy")
 
 # TESTGROUP: dom.suspend
@@ -147,20 +326,18 @@ expect_success(newdom, "no args suspended domain", "resume")
 newdom.destroy
 
 # TESTGROUP: dom.save
-newdom = conn.define_domain_xml($new_dom_xml)
-newdom.create
+newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
 
-expect_too_many_args(newdom, "save", 1, 2)
+expect_too_many_args(newdom, "save", 1, 2, 3, 4)
 expect_too_few_args(newdom, "save")
 expect_invalid_arg_type(newdom, "save", 1)
 expect_invalid_arg_type(newdom, "save", nil)
 expect_fail(newdom, Libvirt::Error, "non-existent path", "save", "/this/path/does/not/exist")
 
-expect_success(newdom, "path arg", "save", "/var/lib/libvirt/images/ruby-libvirt-test.save")
+expect_success(newdom, "path arg", "save", $GUEST_SAVE)
 
-`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
-newdom.undefine
+`rm -f #{$GUEST_SAVE}`
 
 # TESTGROUP: dom.managed_save
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -170,7 +347,7 @@ sleep 1
 expect_too_many_args(newdom, "managed_save", 1, 2)
 expect_invalid_arg_type(newdom, "managed_save", "hello")
 expect_success(newdom, "no args", "managed_save")
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_MANAGED_SAVE)
 
 # TESTGROUP: dom.has_managed_save?
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -181,20 +358,20 @@ expect_too_many_args(newdom, "has_managed_save?", 1, 2)
 expect_invalid_arg_type(newdom, "has_managed_save?", "hello")
 
 if newdom.has_managed_save?
-  puts_fail "dom.has_managed_save? reports true on a new domain"
+  puts_fail "domain.has_managed_save? reports true on a new domain"
 else
-  puts_ok "dom.has_managed_save? not true on new domain"
+  puts_ok "domain.has_managed_save? not true on new domain"
 end
 
 newdom.managed_save
 
 if not newdom.has_managed_save?
-  puts_fail "dom.has_managed_save? reports false after a managed save"
+  puts_fail "domain.has_managed_save? reports false after a managed save"
 else
-  puts_ok "dom.has_managed_save? reports true after a managed save"
+  puts_ok "domain.has_managed_save? reports true after a managed save"
 end
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_MANAGED_SAVE)
 
 # TESTGROUP: dom.managed_save_remove
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -206,13 +383,13 @@ expect_too_many_args(newdom, "managed_save_remove", 1, 2)
 expect_invalid_arg_type(newdom, "managed_save_remove", "hello")
 
 if not newdom.has_managed_save?
-  puts_fail "prior to dom.managed_save_remove, no managed save file"
+  puts_fail "prior to domain.managed_save_remove, no managed save file"
 end
 expect_success(newdom, "no args", "managed_save_remove")
 if newdom.has_managed_save?
-  puts_fail "after dom.managed_save_remove, managed save file still exists"
+  puts_fail "after domain.managed_save_remove, managed save file still exists"
 else
-  puts_ok "after dom.managed_save_remove, managed save file no longer exists"
+  puts_ok "after domain.managed_save_remove, managed save file no longer exists"
 end
 
 newdom.undefine
@@ -244,7 +421,7 @@ newdom.undefine
 newdom = conn.define_domain_xml($new_dom_xml)
 newdom.create
 sleep 1
-newdom.save("/var/lib/libvirt/images/ruby-libvirt-test.save")
+newdom.save($GUEST_SAVE)
 
 expect_too_many_args(Libvirt::Domain, "restore", 1, 2, 3)
 expect_too_few_args(Libvirt::Domain, "restore")
@@ -255,9 +432,9 @@ expect_fail(Libvirt::Domain, Libvirt::Error, "invalid path", "restore", conn, "/
 expect_fail(Libvirt::Domain, Libvirt::Error, "invalid save file", "restore", conn, "/tmp/foo")
 `rm -f /tmp/foo`
 
-expect_success(Libvirt::Domain, "2 args", "restore", conn, "/var/lib/libvirt/images/ruby-libvirt-test.save")
+expect_success(Libvirt::Domain, "2 args", "restore", conn, $GUEST_SAVE)
 
-`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
+`rm -f #{$GUEST_SAVE}`
 
 newdom.destroy
 newdom.undefine
@@ -336,12 +513,12 @@ expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "block_peek", "foo",
 
 blockpeek = newdom.block_peek($GUEST_DISK, 0, 512)
 
-# 51 46 49 fb are the first 4 bytes of a qcow2 image
-if blockpeek[0] != 0x51 or blockpeek[1] != 0x46 or blockpeek[2] != 0x49 or
-    blockpeek[3] != 0xfb
-  puts_fail "dom.block_peek read did not return valid data"
+# 0x51 0x46 0x49 0xfb are the first 4 bytes of a qcow2 image
+if blockpeek[0].unpack('C')[0] != 0x51 or blockpeek[1].unpack('C')[0] != 0x46 or
+  blockpeek[2].unpack('C')[0] != 0x49 or blockpeek[3].unpack('C')[0] != 0xfb
+  puts_fail "domain.block_peek read did not return valid data"
 else
-  puts_ok "dom.block_peek read valid data"
+  puts_ok "domain.block_peek read valid data"
 end
 
 newdom.destroy
@@ -362,24 +539,22 @@ expect_success(newdom, "offset and size args", "memory_peek", 0, 512)
 newdom.destroy
 
 # TESTGROUP: dom.get_vcpus
-newdom = conn.create_domain_xml($new_dom_xml)
-sleep 1
-
 expect_too_many_args(newdom, "get_vcpus", 1)
 
-expect_success(newdom, "no args", "get_vcpus") {|x| x.length == 2}
+newdom = conn.define_domain_xml($new_dom_xml)
 
-newdom.destroy
+expect_success(newdom, "get_vcpus on shutoff domain", "get_vcpus") {|x| x.length == 2}
 
-# TESTGROUP: dom.active?
-newdom = conn.create_domain_xml($new_dom_xml)
+newdom.create
 sleep 1
 
-expect_too_many_args(newdom, "active?", 1)
-
-expect_success(newdom, "no args", "active?") {|x| x == true}
+expect_success(newdom, "no args", "get_vcpus") {|x| x.length == 2}
 
 newdom.destroy
+newdom.undefine
+
+# TESTGROUP: dom.active?
+expect_too_many_args(newdom, "active?", 1)
 
 newdom = conn.define_domain_xml($new_dom_xml)
 
@@ -479,15 +654,7 @@ expect_too_many_args(newdom, "max_memory=", 1, 2)
 expect_too_few_args(newdom, "max_memory=")
 expect_invalid_arg_type(newdom, "max_memory=", 'foo')
 
-begin
-  newdom.max_memory = 200000
-  puts_ok "dom.max_memory= succeded"
-rescue NoMethodError
-  puts_skipped "dom.max_memory does not exist"
-rescue Libvirt::DefinitionError => e
-  # dom.max_memory is not supported by Qemu; skip
-  puts_skipped "dom.max_memory not supported by connection driver"
-end
+expect_success(newdom, "memory arg", "max_memory=", 200000)
 
 newdom.undefine
 
@@ -495,10 +662,11 @@ newdom.undefine
 newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "memory=", 1, 2)
+expect_too_many_args(newdom, "memory=", [1, 2, 3])
 expect_too_few_args(newdom, "memory=")
+expect_too_few_args(newdom, "memory=", [])
 expect_invalid_arg_type(newdom, "memory=", 'foo')
-
-expect_fail(newdom, Libvirt::Error, "shutoff domain", "memory=", 2)
+expect_fail(newdom, Libvirt::Error, "shutoff domain", "memory=", [2, Libvirt::Domain::AFFECT_LIVE])
 
 newdom.undefine
 
@@ -523,18 +691,18 @@ newdom.destroy
 newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "vcpus=", 1, 2)
+expect_too_many_args(newdom, "vcpus=", [0, 1, 2])
 expect_too_few_args(newdom, "vcpus=")
+expect_too_few_args(newdom, "vcpus=", [])
 expect_invalid_arg_type(newdom, "vcpus=", 'foo')
-
-expect_fail(newdom, Libvirt::Error, "shutoff domain", "vcpus=", 2)
+expect_fail(newdom, Libvirt::Error, "shutoff domain", "vcpus=", [2, Libvirt::Domain::AFFECT_LIVE])
 
 newdom.undefine
 
 newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
 
-# FIXME: this kills the domain for some reason
-#expect_success(newdom, "number arg", "vcpus=", 2)
+expect_success(newdom, "number arg", "vcpus=", 2)
 
 newdom.destroy
 
@@ -542,7 +710,7 @@ newdom.destroy
 newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
 
-expect_too_many_args(newdom, "pin_vcpu", 1, 2, 3)
+expect_too_many_args(newdom, "pin_vcpu", 1, 2, 3, 4)
 expect_too_few_args(newdom, "pin_vcpu")
 expect_invalid_arg_type(newdom, "pin_vcpu", 'foo', [0])
 expect_invalid_arg_type(newdom, "pin_vcpu", 0, 1)
@@ -565,7 +733,7 @@ newdom.destroy
 # TESTGROUP: dom.undefine
 newdom = conn.define_domain_xml($new_dom_xml)
 
-expect_too_many_args(newdom, "undefine", 1)
+expect_too_many_args(newdom, "undefine", 1, 2)
 
 expect_success(newdom, "no args", "undefine")
 
@@ -605,16 +773,16 @@ expect_invalid_arg_type(newdom, "autostart=", 1234)
 
 expect_success(newdom, "true arg", "autostart=", true)
 if not newdom.autostart?
-  puts_fail "dom.autostart= did not set autostart to true"
+  puts_fail "domain.autostart= did not set autostart to true"
 else
-  puts_ok "dom.autostart= set autostart to true"
+  puts_ok "domain.autostart= set autostart to true"
 end
 
 expect_success(newdom, "false arg", "autostart=", false)
 if newdom.autostart?
-  puts_fail "dom.autostart= did not set autostart to false"
+  puts_fail "domain.autostart= did not set autostart to false"
 else
-  puts_ok "dom.autostart= set autostart to false"
+  puts_ok "domain.autostart= set autostart to false"
 end
 
 newdom.undefine
@@ -681,8 +849,7 @@ newdom = conn.define_domain_xml($new_dom_xml)
 newdom.undefine
 expect_too_many_args(newdom, "free", 1)
 
-newdom.free
-puts_ok "dom.free succeeded"
+expect_success(newdom, "free", "free")
 
 # TESTGROUP: dom.snapshot_create_xml
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -697,12 +864,12 @@ expect_success(newdom, "simple XML arg", "snapshot_create_xml", "<domainsnapshot
 
 snaps = newdom.num_of_snapshots
 if snaps != 1
-  puts_fail "dom.snapshot_create_xml after one snapshot has #{snaps} snapshots"
+  puts_fail "domain.snapshot_create_xml after one snapshot has #{snaps} snapshots"
 else
-  puts_ok "dom.snapshot_create_xml after one snapshot has 1 snapshot"
+  puts_ok "domain.snapshot_create_xml after one snapshot has 1 snapshot"
 end
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.num_of_snapshots
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -716,7 +883,7 @@ newdom.snapshot_create_xml("<domainsnapshot/>")
 
 expect_success(newdom, "no args", "num_of_snapshots") {|x| x == 1}
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.list_snapshots
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -730,7 +897,7 @@ newdom.snapshot_create_xml("<domainsnapshot/>")
 
 expect_success(newdom, "no args", "list_snapshots") {|x| x.length == 1}
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.lookup_snapshot_by_name
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -743,7 +910,7 @@ expect_invalid_arg_type(newdom, "lookup_snapshot_by_name", 'foo', 'bar')
 
 expect_success(newdom, "name arg", "lookup_snapshot_by_name", "foo")
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.has_current_snapshot?
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -757,7 +924,7 @@ newdom.snapshot_create_xml("<domainsnapshot><name>foo</name></domainsnapshot>")
 
 expect_success(newdom, "no args", "has_current_snapshot?") {|x| x == true}
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.revert_to_snapshot
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -775,7 +942,7 @@ expect_invalid_arg_type(newdom, "revert_to_snapshot", snap, 'foo')
 
 expect_success(newdom, "snapshot arg", "revert_to_snapshot", snap)
 
-newdom.undefine
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.current_snapshot
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -788,36 +955,7 @@ newdom.snapshot_create_xml("<domainsnapshot><name>foo</name></domainsnapshot>")
 
 expect_success(newdom, "no args", "current_snapshot")
 
-newdom.undefine
-
-# TESTGROUP: snapshot.xml_desc
-newdom = conn.define_domain_xml($new_dom_xml)
-snap = newdom.snapshot_create_xml("<domainsnapshot/>")
-
-expect_too_many_args(snap, "xml_desc", 1, 2)
-expect_invalid_arg_type(snap, "xml_desc", 'foo')
-
-expect_success(newdom, "no args", "xml_desc")
-
-newdom.undefine
-
-# TESTGROUP: snapshot.delete
-newdom = conn.define_domain_xml($new_dom_xml)
-snap = newdom.snapshot_create_xml("<domainsnapshot/>")
-
-expect_too_many_args(snap, "delete", 1, 2)
-expect_invalid_arg_type(snap, "delete", 'foo')
-
-expect_success(snap, "no args", "delete")
-
-newdom.undefine
-
-# TESTGROUP: snapshot.free
-newdom = conn.define_domain_xml($new_dom_xml)
-newdom.undefine
-expect_too_many_args(newdom, "free", 1)
-
-expect_success(newdom, "no args", "free")
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
 
 # TESTGROUP: dom.job_info
 newdom = conn.define_domain_xml($new_dom_xml)
@@ -859,32 +997,16 @@ newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "scheduler_type", 1)
 
-begin
-  newdom.scheduler_type
-  puts_ok "dom.scheduler_type succeeded"
-rescue NoMethodError
-  puts_skipped "dom.scheduler_type does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_skipped "dom.scheduler_type not supported"
-end
+expect_success(newdom, "no args", "scheduler_type")
 
 newdom.undefine
 
 # TESTGROUP: dom.scheduler_parameters
 newdom = conn.define_domain_xml($new_dom_xml)
 
-expect_too_many_args(newdom, "scheduler_parameters", 1)
+expect_too_many_args(newdom, "scheduler_parameters", 1, 1)
 
-begin
-  newdom.scheduler_parameters
-  puts_ok "dom.scheduler_parameters succeeded"
-rescue NoMethodError
-  puts_skipped "dom.scheduler_parameters does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_ok "dom.scheduler_parameters not supported"
-end
+expect_success(newdom, "no args", "scheduler_parameters")
 
 newdom.undefine
 
@@ -895,14 +1017,7 @@ expect_too_many_args(newdom, "scheduler_parameters=", 1, 2)
 expect_too_few_args(newdom, "scheduler_parameters=")
 expect_invalid_arg_type(newdom, "scheduler_parameters=", 0)
 
-begin
-  newdom.scheduler_parameters={"cpu_shares"=>512}
-rescue NoMethodError
-  puts_skipped "dom.scheduler_parameters= does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_ok "dom.scheduler_parameters= not supported"
-end
+expect_success(newdom, "cpu shares arg", "scheduler_parameters=", {"cpu_shares" => 512})
 
 newdom.undefine
 
@@ -942,11 +1057,12 @@ expect_too_many_args(newdom, "qemu_monitor_command", 1, 2, 3)
 expect_too_few_args(newdom, "qemu_monitor_command")
 expect_invalid_arg_type(newdom, "qemu_monitor_command", 1)
 expect_invalid_arg_type(newdom, "qemu_monitor_command", "foo", "bar")
-testconn = Libvirt::open("test:///default")
-fakedom = testconn.create_domain_xml(new_test_xml)
-expect_invalid_arg_type(fakedom, "qemu_monitor_command", "foo")
-fakedom.destroy
-testconn.close
+# FIXME: the test driver doesn't support virDomainDestroyFlags() presently
+#testconn = Libvirt::open("test:///default")
+#fakedom = testconn.create_domain_xml(new_test_xml)
+#expect_invalid_arg_type(fakedom, "qemu_monitor_command", "foo")
+#fakedom.destroy
+#testconn.close
 expect_fail(newdom, Libvirt::RetrieveError, "invalid command", "qemu_monitor_command", "foo")
 
 expect_success(newdom, "monitor command", "qemu_monitor_command", '{"execute":"query-cpus"}')
@@ -959,7 +1075,6 @@ newdom = conn.define_domain_xml($new_dom_xml)
 expect_too_many_args(newdom, "num_vcpus", 1, 2)
 expect_too_few_args(newdom, "num_vcpus")
 expect_invalid_arg_type(newdom, "num_vcpus", 'foo')
-expect_fail(newdom, Libvirt::Error, "zero flags", "num_vcpus", 0)
 expect_fail(newdom, Libvirt::Error, "active flag on shutoff domain", "num_vcpus", Libvirt::Domain::VCPU_LIVE)
 expect_fail(newdom, Libvirt::Error, "live and config flags", "num_vcpus", Libvirt::Domain::VCPU_LIVE | Libvirt::Domain::VCPU_CONFIG)
 expect_success(newdom, "config flag", "num_vcpus", Libvirt::Domain::VCPU_CONFIG) {|x| x == 2}
@@ -969,55 +1084,27 @@ newdom.undefine
 newdom = conn.create_domain_xml($new_dom_xml)
 sleep 1
 
-expect_success(newdom, "config flag on transient domain", "num_vcpus", Libvirt::Domain::VCPU_CONFIG)
+expect_fail(newdom, Libvirt::RetrieveError, "config flag on transient domain", "num_vcpus", Libvirt::Domain::VCPU_CONFIG)
 expect_success(newdom, "live flag on transient domain", "num_vcpus", Libvirt::Domain::VCPU_LIVE)
 
 newdom.destroy
 
 # TESTGROUP: dom.vcpus_flags=
-newdom = conn.define_domain_xml($new_dom_xml)
-
-expect_too_many_args(newdom, "vcpus_flags=", 1, 2, 3)
-expect_too_few_args(newdom, "vcpus_flags=")
-expect_invalid_arg_type(newdom, "vcpus_flags=", 1)
-expect_invalid_arg_type(newdom, "vcpus_flags=", ['foo', 2])
-expect_invalid_arg_type(newdom, "vcpus_flags=", [2, 'foo'])
-expect_fail(newdom, Libvirt::Error, "zero flags", "vcpus_flags=", [2, 0])
-expect_fail(newdom, Libvirt::Error, "zero vcpus", "vcpus_flags=", [0, Libvirt::Domain::VCPU_CONFIG])
-expect_fail(newdom, Libvirt::Error, "live vcpu on shutoff domain", "vcpus_flags=", [2, Libvirt::Domain::VCPU_LIVE])
-expect_success(newdom, "2 vcpu config", "vcpus_flags=", [2, Libvirt::Domain::VCPU_CONFIG])
-
-newdom.undefine
-
-newdom = conn.create_domain_xml($new_dom_xml)
-sleep 1
-
-expect_fail(newdom, Libvirt::Error, "vcpu config on transient domain", "vcpus_flags=", [2, Libvirt::Domain::VCPU_CONFIG])
-expect_fail(newdom, Libvirt::Error, "too many vcpus", "vcpus_flags=", [4, Libvirt::Domain::VCPU_LIVE])
-
-# FIXME: this doesn't work for some reason
-#expect_success(newdom, "vcpus to 1", "vcpus_flags=", [1, Libvirt::Domain::VCPU_LIVE])
-
-newdom.destroy
+# dom.vcpus_flags= is deprecated in favor of dom.vcpus=, so we don't do any
+# tests here for it
 
 # TESTGROUP: dom.memory_parameters=
 newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "memory_parameters=", 1, 2, 3)
+expect_too_many_args(newdom, "memory_parameters=", [1, 2, 3])
 expect_too_few_args(newdom, "memory_parameters=")
+expect_too_few_args(newdom, "memory_parameters=", [])
 expect_invalid_arg_type(newdom, "memory_parameters=", 0)
-expect_fail(newdom, ArgumentError, "empty array", "memory_parameters=", [])
 expect_invalid_arg_type(newdom, "memory_parameters=", [1, 0])
 expect_invalid_arg_type(newdom, "memory_parameters=", [{}, "foo"])
 
-begin
-  newdom.memory_parameters={"soft_limit" => 9007199254740999, "swap_hard_limit" => 9007199254740999}
-rescue NoMethodError
-  puts_skipped "dom.memory_parameters= does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_skipped "memory_parameters= not supported"
-end
+expect_success(newdom, "soft and hard limit", "memory_parameters=", {"soft_limit" => 9007199254740999, "swap_hard_limit" => 9007199254740999})
 
 newdom.undefine
 
@@ -1026,15 +1113,7 @@ newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "memory_parameters", 1, 2)
 
-begin
-  newdom.memory_parameters
-  puts_ok "dom.memory_parameters succeeded"
-rescue NoMethodError
-  puts_skipped "memory_parameters does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_skipped "memory_parameters not supported"
-end
+expect_success(newdom, "no args", "memory_parameters")
 
 newdom.undefine
 
@@ -1042,20 +1121,14 @@ newdom.undefine
 newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "blkio_parameters=", 1, 2, 3)
+expect_too_many_args(newdom, "blkio_parameters=", [1, 2, 3])
 expect_too_few_args(newdom, "blkio_parameters=")
+expect_too_few_args(newdom, "blkio_parameters=", [])
 expect_invalid_arg_type(newdom, "blkio_parameters=", 0)
-expect_fail(newdom, ArgumentError, "empty array", "blkio_parameters=", [])
 expect_invalid_arg_type(newdom, "blkio_parameters=", [1, 0])
 expect_invalid_arg_type(newdom, "blkio_parameters=", [{}, "foo"])
 
-begin
-  newdom.blkio_parameters={"weight" => 1}
-rescue NoMethodError
-  puts_skipped "blkio_parameters= does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_skipped "blkio_parameters= not supported"
-end
+expect_success(newdom, "hash", "blkio_parameters=", {"weight" => 100})
 
 newdom.undefine
 
@@ -1064,20 +1137,12 @@ newdom = conn.define_domain_xml($new_dom_xml)
 
 expect_too_many_args(newdom, "blkio_parameters", 1, 2)
 
-begin
-  newdom.blkio_parameters
-  puts_ok "dom.blkio_parameters succeeded"
-rescue NoMethodError
-  puts_skipped "blkio_parameters does not exist"
-rescue Libvirt::RetrieveError
-  # this may not be supported (if cgroups aren't configured), so skip it
-  puts_skipped "blkio_parameters not supported"
-end
+expect_success(newdom, "no args", "blkio_parameters")
 
 newdom.undefine
 
 # TESTGROUP: dom.open_console
-newdom = conn.create_domain_xml(new_dom_xml)
+newdom = conn.create_domain_xml($new_dom_xml)
 stream = conn.stream
 
 expect_too_many_args(newdom, "open_console", 1, 2, 3, 4)
@@ -1087,10 +1152,289 @@ expect_invalid_arg_type(newdom, "open_console", 1, stream)
 expect_invalid_arg_type(newdom, "open_console", "pty", 1)
 expect_invalid_arg_type(newdom, "open_console", "pty", stream, "wow")
 
-expect_success(newdom, "device and stream args", "open_console", "pty", stream)
+#expect_success(newdom, "device and stream args", "open_console", "pty", stream)
+
+newdom.destroy
+
+# TESTGROUP: dom.block_rebase
+newdom = conn.create_domain_xml($new_dom_xml)
+
+expect_too_many_args(newdom, "block_rebase", 1, 2, 3, 4, 5)
+expect_too_few_args(newdom, "block_rebase")
+expect_invalid_arg_type(newdom, "block_rebase", 1)
+expect_invalid_arg_type(newdom, "block_rebase", "foo", 1)
+expect_invalid_arg_type(newdom, "block_rebase", "foo", "bar", "baz")
+expect_invalid_arg_type(newdom, "block_rebase", "foo", "bar", 1, "boom")
+
+# FIXME: I don't know how to make block_rebase work
+#expect_success(newdom, "disk", "block_rebase", diskname)
+
+newdom.destroy
+
+# TESTGROUP: dom.migrate_max_downtime=
+newdom = conn.define_domain_xml($new_dom_xml)
+
+expect_too_many_args(newdom, "migrate_max_downtime=", 1, 2)
+expect_too_many_args(newdom, "migrate_max_downtime=", [1, 2, 3])
+expect_too_few_args(newdom, "migrate_max_downtime=")
+expect_too_few_args(newdom, "migrate_max_downtime=", [])
+expect_invalid_arg_type(newdom, "migrate_max_downtime=", 'foo')
+expect_invalid_arg_type(newdom, "migrate_max_downtime=", nil)
+expect_fail(newdom, Libvirt::Error, "on off domain", "migrate_max_downtime=", 10)
+expect_fail(newdom, Libvirt::Error, "on off domain, two args", "migrate_max_downtime=", [10, 10])
+
+newdom.undefine
+
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+expect_fail(newdom, Libvirt::Error, "while no migration in progress", "migrate_max_downtime=", 10)
+
+# FIXME: get this working
+#newdom.migrate_to_uri("qemu://remote/system")
+#expect_success(newdom, "10 second downtime", "migrate_max_downtime=", 10)
+
+newdom.destroy
+
+# TESTGROUP: dom.migrate_max_speed=
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "migrate_max_speed=", 1, 2)
+expect_too_many_args(newdom, "migrate_max_speed=", [1, 2, 3])
+expect_too_few_args(newdom, "migrate_max_speed=")
+expect_too_few_args(newdom, "migrate_max_speed=", [])
+expect_invalid_arg_type(newdom, "migrate_max_speed=", 'foo')
+expect_invalid_arg_type(newdom, "migrate_max_speed=", nil)
+expect_invalid_arg_type(newdom, "migrate_max_speed=", ['foo', 1])
+expect_invalid_arg_type(newdom, "migrate_max_speed=", [1, 'foo'])
+
+#expect_success(newdom, "Bandwidth arg", "migrate_max_speed=", 5)
+
+newdom.destroy
+
+# TESTGROUP: dom.state
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "state", 1, 2)
+expect_invalid_arg_type(newdom, "state", 'foo')
+
+expect_success(newdom, "no arg", "state")
 
 newdom.destroy
 
+# TESTGROUP: dom.screenshot
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+stream = conn.stream
+
+expect_too_many_args(newdom, "screenshot", 1, 2, 3, 4)
+expect_too_few_args(newdom, "screenshot")
+expect_too_few_args(newdom, "screenshot", stream)
+expect_invalid_arg_type(newdom, "screenshot", 1, 0)
+expect_invalid_arg_type(newdom, "screenshot", nil, 0)
+expect_invalid_arg_type(newdom, "screenshot", stream, nil)
+expect_invalid_arg_type(newdom, "screenshot", stream, 'foo')
+expect_invalid_arg_type(newdom, "screenshot", stream, 0, 'foo')
+
+expect_success(newdom, "stream and screen arg", "screenshot", stream, 0)
+
+newdom.destroy
+
+# TESTGROUP: dom.vcpus_flags=
+newdom = conn.define_domain_xml($new_dom_xml)
+
+expect_too_many_args(newdom, "vcpus_flags=", 1, 2)
+expect_too_many_args(newdom, "vcpus_flags=", [0, 1, 2])
+expect_too_few_args(newdom, "vcpus_flags=")
+expect_too_few_args(newdom, "vcpus_flags=", [])
+expect_invalid_arg_type(newdom, "vcpus_flags=", 'foo')
+expect_fail(newdom, Libvirt::Error, "shutoff domain", "vcpus_flags=", [2, Libvirt::Domain::AFFECT_LIVE])
+
+newdom.undefine
+
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_success(newdom, "number arg", "vcpus_flags=", 2)
+
+newdom.destroy
+
+# TESTGROUP: domain.list_all_snapshots
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(newdom, "list_all_snapshots", 1, 2)
+expect_invalid_arg_type(newdom, "list_all_snapshots", 'foo')
+
+expect_success(newdom, "no args", "list_all_snapshots")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: domain.open_graphics
+newdom = conn.create_domain_xml($new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "open_graphics", 1, 2, 3, 4)
+expect_too_few_args(newdom, "open_graphics")
+expect_invalid_arg_type(newdom, "open_graphics", nil)
+expect_invalid_arg_type(newdom, "open_graphics", 'foo')
+expect_invalid_arg_type(newdom, "open_graphics", [])
+expect_invalid_arg_type(newdom, "open_graphics", {})
+expect_invalid_arg_type(newdom, "open_graphics", 4, 'foo')
+expect_invalid_arg_type(newdom, "open_graphics", 4, [])
+expect_invalid_arg_type(newdom, "open_graphics", 4, {})
+expect_invalid_arg_type(newdom, "open_graphics", 4, 0, 'foo')
+expect_invalid_arg_type(newdom, "open_graphics", 4, 0, [])
+expect_invalid_arg_type(newdom, "open_graphics", 4, 0, {})
+
+#expect_success(newdom, "fd arg", "open_graphics", fd)
+
+set_test_object("snapshot")
+
+# TESTGROUP: snapshot.xml_desc
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "xml_desc", 1, 2)
+expect_invalid_arg_type(snap, "xml_desc", 'foo')
+
+expect_success(newdom, "no args", "xml_desc")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.delete
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "delete", 1, 2)
+expect_invalid_arg_type(snap, "delete", 'foo')
+
+expect_success(snap, "no args", "delete")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.name
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "name", 1)
+
+expect_success(snap, "no args", "name")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.num_children
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "num_children", 1, 2)
+
+expect_success(snap, "no args, no children", "num_children") {|x| x == 0}
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.list_children_names
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "list_children_names", 1, 2)
+
+expect_success(snap, "no args, no children", "num_children") {|x| x == 0}
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.free
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "free", 1)
+
+expect_success(snap, "no args", "free")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.has_metadata?
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "has_metadata?", 1, 2)
+expect_invalid_arg_type(snap, "has_metadata?", "foo")
+
+expect_success(snap, "no args", "has_metadata?") {|x| x == true}
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.list_children_names
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot><name>snap</name></domainsnapshot>")
+snap2 = newdom.snapshot_create_xml("<domainsnapshot><name>snap2</name></domainsnapshot>")
+
+expect_too_many_args(snap, "list_children_names", 1, 2)
+expect_invalid_arg_type(snap, "list_children_names", "foo")
+expect_invalid_arg_type(snap, "list_children_names", [])
+expect_invalid_arg_type(snap, "list_children_names", {})
+
+expect_success(snap, "no args", "list_children_names")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.list_all_children
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "list_all_children", 1, 2)
+expect_invalid_arg_type(snap, "list_all_children", "foo")
+expect_invalid_arg_type(snap, "list_all_children", [])
+expect_invalid_arg_type(snap, "list_all_children", {})
+
+expect_success(snap, "no args", "list_all_children")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.parent
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+snap2 = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap2, "parent", 1, 2)
+expect_invalid_arg_type(snap2, "parent", "foo")
+expect_invalid_arg_type(snap2, "parent", [])
+expect_invalid_arg_type(snap2, "parent", {})
+
+expect_success(snap2, "no args", "parent")
+expect_success(snap, "no args", "parent")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# TESTGROUP: snapshot.current?
+newdom = conn.define_domain_xml($new_dom_xml)
+snap = newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_too_many_args(snap, "current?", 1, 2)
+expect_invalid_arg_type(snap, "current?", "foo")
+expect_invalid_arg_type(snap, "current?", [])
+expect_invalid_arg_type(snap, "current?", {})
+
+expect_success(snap, "no args", "current?")
+
+newdom.undefine(Libvirt::Domain::UNDEFINE_SNAPSHOTS_METADATA)
+sleep 1
+
+# END TESTS
+
 conn.close
 
 finish_tests