ruby-libvirt 0.2.0 → 0.3.0

data/tests/test_conn.rb

@@ -2,52 +2,202 @@
 
 # Test the conn methods the bindings support
 
+$: << File.dirname(__FILE__)
+
 require 'libvirt'
+require 'test_utils.rb'
+
+conn = Libvirt::open("qemu:///system")
+
+cpu_xml = <<EOF
+<cpu>
+  <arch>x86_64</arch>
+  <model>athlon</model>
+</cpu>
+EOF
+
+# TESTGROUP: conn.close
+conn2 = Libvirt::open("qemu:///system")
+expect_too_many_args(conn2, "close", 1)
+expect_success(conn2, "no args", "close")
+
+# TESTGROUP: conn.closed?
+conn2 = Libvirt::open("qemu:///system")
+
+expect_too_many_args(conn2, "closed?", 1)
+expect_success(conn2, "no args", "closed?") {|x| x == false }
+conn2.close
+expect_success(conn2, "no args", "closed?") {|x| x == true }
+
+# TESTGROUP: conn.type
+expect_too_many_args(conn, "type", 1)
+
+expect_success(conn, "no args", "type") {|x| x == "QEMU"}
+
+# TESTGROUP: conn.version
+expect_too_many_args(conn, "version", 1)
+
+expect_success(conn, "no args", "version")
+
+# TESTGROUP: conn.libversion
+expect_too_many_args(conn, "libversion", 1)
+
+expect_success(conn, "no args", "libversion")
+
+# TESTGROUP: conn.hostname
+expect_too_many_args(conn, "hostname", 1)
 
-conn = Libvirt::open
-puts "Connection:"
-puts " Closed?:          #{conn.closed?}"
-puts " Type:             #{conn.type}"
-puts " Version:          #{conn.version}"
-puts " Libversion:       #{conn.libversion}"
-puts " Hostname:         #{conn.hostname}"
-puts " URI:              #{conn.uri}"
-puts " Max VCPUs:        #{conn.max_vcpus}"
-puts " Max VCPUs (kvm):  #{conn.max_vcpus("kvm")}"
-puts " Max VCPUs (qemu): #{conn.max_vcpus("qemu")}"
-puts " Node Free Memory: #{conn.node_free_memory}kb"
-puts " Node Cells Free Memory:"
-cell_free_mem = conn.node_cells_free_memory
-cell_free_mem.each_index do |cell|
-  puts "  Cell: #{cell}, Free Memory: #{cell_free_mem[cell]}kb"
+expect_success(conn, "no args", "hostname")
+
+# TESTGROUP: conn.uri
+expect_too_many_args(conn, "uri", 1)
+
+expect_success(conn, "no args", "uri") {|x| x == "qemu:///system" }
+
+# TESTGROUP: conn.max_vcpus
+expect_too_many_args(conn, "max_vcpus", 'kvm', 1)
+expect_fail(conn, Libvirt::RetrieveError, "invalid arg", "max_vcpus", "foo")
+
+expect_success(conn, "no args", "max_vcpus")
+expect_success(conn, "nil arg", "max_vcpus")
+expect_success(conn, "kvm arg", "max_vcpus")
+expect_success(conn, "qemu arg", "max_vcpus")
+
+# TESTGROUP: conn.node_get_info
+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
+
+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
-puts " Node Cells Free Memory (0-):"
-cell_free_mem = conn.node_cells_free_memory(0)
-cell_free_mem.each_index do |cell|
-  puts "  Cell: #{cell}, Free Memory: #{cell_free_mem[cell]}kb"
+
+# TESTGROUP: conn.node_get_security_model
+expect_too_many_args(conn, "node_get_security_model", 1)
+expect_success(conn, "no args", "node_get_security_model")
+
+# TESTGROUP: conn.encrypted?
+expect_too_many_args(conn, "encrypted?", 1)
+expect_success(conn, "no args", "encrypted?")
+
+# TESTGROUP: conn.secure?
+expect_too_many_args(conn, "secure?", 1)
+expect_success(conn, "no args", "secure?") {|x| x == true}
+
+# TESTGROUP: conn.capabilities
+expect_too_many_args(conn, "capabilities", 1)
+expect_success(conn, "no args", "capabilities")
+
+# TESTGROUP: conn.compare_cpu
+expect_too_many_args(conn, "compare_cpu", 1, 2, 3)
+expect_too_few_args(conn, "compare_cpu")
+expect_invalid_arg_type(conn, "compare_cpu", 1)
+expect_invalid_arg_type(conn, "compare_cpu", "hello", 'bar')
+expect_fail(conn, Libvirt::RetrieveError, "invalid XML", "compare_cpu", "hello")
+expect_success(conn, "CPU XML", "compare_cpu", cpu_xml)
+
+# TESTGROUP: conn.baseline_cpu
+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_fail(conn, ArgumentError, "empty array", "baseline_cpu", [])
+expect_success(conn, "CPU XML", "baseline_cpu", [cpu_xml])
+
+# TESTGROUP: conn.domain_event_register_any
+dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
+}
+
+def dom_event_callback_symbol(conn, dom, event, detail, opaque)
 end
-puts " Node Cells Free Memory (0-1):"
-cell_free_mem = conn.node_cells_free_memory(0, 1)
-cell_free_mem.each_index do |cell|
-  puts "  Cell: #{cell}, Free Memory: #{cell_free_mem[cell]}kb"
+
+expect_too_many_args(conn, "domain_event_register_any", 1, 2, 3, 4, 5)
+expect_too_few_args(conn, "domain_event_register_any")
+expect_too_few_args(conn, "domain_event_register_any", 1)
+expect_invalid_arg_type(conn, "domain_event_register_any", "hello", 1)
+expect_invalid_arg_type(conn, "domain_event_register_any", Libvirt::Connect::DOMAIN_EVENT_ID_LIFECYCLE, 1)
+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 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, 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|
+}
+
+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)
+
+# TESTGROUP: conn.domain_event_register
+dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
+}
+
+def dom_event_callback_symbol(conn, dom, event, detail, opaque)
 end
-secmodel = conn.node_get_security_model
-puts " Node Security Model:"
-puts "  Model: #{secmodel.model}"
-puts "  DOI:   #{secmodel.doi}"
-puts " Encrypted?: #{conn.encrypted?}"
-puts " Secure?: #{conn.secure?}"
-info = conn.node_get_info
-puts " Node Info:"
-puts "  Model:   #{info.model}"
-puts "  Memory:  #{info.memory}"
-puts "  CPUs:    #{info.cpus}"
-puts "  MHz:     #{info.mhz}"
-puts "  Nodes:   #{info.nodes}"
-puts "  Sockets: #{info.sockets}"
-puts "  Cores:   #{info.cores}"
-puts "  Threads: #{info.threads}"
-puts " Capabilities:"
-puts conn.capabilities
+
+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, "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
+
+# TESTGROUP: conn.domain_event_deregister
+dom_event_callback_proc = lambda {|conn, dom, event, detail, opaque|
+}
+
+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")
+
 conn.close
-puts "After close, conn closed? = #{conn.closed?}"
+
+finish_tests

data/tests/test_domain.rb

@@ -1,20 +1,38 @@
 #!/usr/bin/ruby
 
-# Test the domain methods the bindings support
+# Test the domain methods the bindings support.  Note that this tester requires
+# the qemu driver to be enabled and available for use.
+
+# Note that the order of the TESTGROUPs below match the order that the
+# functions are defined in the ext/libvirt/domain.c file
+
+$: << File.dirname(__FILE__)
 
 require 'libvirt'
+require 'test_utils.rb'
+
+GUEST_DISK = '/var/lib/libvirt/images/ruby-libvirt-tester.qcow2'
+UUID = "93a5c045-6457-2c09-e56f-927cdf34e17a"
+
+conn = Libvirt::open("qemu:///system")
 
-conn = Libvirt::open
-puts "Number of Domains: #{conn.num_of_domains}"
-puts "Number of Defined Domains: #{conn.num_of_defined_domains}"
-puts "Domain Create:"
+# 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
+
+# XML data for later tests
 new_dom_xml = <<EOF
 <domain type='kvm'>
   <name>ruby-libvirt-tester</name>
-  <uuid>93a5c045-6457-2c09-e56f-927cdf34e17a</uuid>
+  <uuid>#{UUID}</uuid>
   <memory>1048576</memory>
   <currentMemory>1048576</currentMemory>
-  <vcpu>1</vcpu>
+  <vcpu>2</vcpu>
   <os>
     <type arch='x86_64'>hvm</type>
     <boot dev='hd'/>
@@ -29,15 +47,14 @@ new_dom_xml = <<EOF
   <on_reboot>restart</on_reboot>
   <on_crash>restart</on_crash>
   <devices>
-    <emulator>/usr/libexec/qemu-kvm</emulator>
     <disk type='file' device='disk'>
-      <driver name='qemu' type='raw'/>
-      <source file='/var/lib/libvirt/images/ruby-libvirt-test.dsk'/>
+      <driver name='qemu' type='qcow2'/>
+      <source file='#{GUEST_DISK}'/>
       <target dev='vda' bus='virtio'/>
     </disk>
     <interface type='bridge'>
       <mac address='52:54:00:60:3c:95'/>
-      <source bridge='br0'/>
+      <source bridge='virbr0'/>
       <model type='virtio'/>
       <target dev='rl556'/>
     </interface>
@@ -56,110 +73,1058 @@ new_dom_xml = <<EOF
 </domain>
 EOF
 
+# qemu command-line that roughly corresponds to the above XML
+qemu_cmd_line = "/usr/bin/qemu-kvm -S -M pc-0.13 -enable-kvm -m 1024 -smp 1,sockets=1,cores=1,threads=1 -name ruby-libvirt-tester -uuid #{UUID} -nodefconfig -nodefaults -chardev socket,id=monitor,path=/var/lib/libvirt/qemu/ruby-libvirt-tester.monitor,server,nowait -mon chardev=monitor,mode=readline -rtc base=utc -boot c -chardev pty,id=serial0 -device isa-serial,chardev=serial0 -usb -vnc 127.0.0.1:0 -k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5"
+
+# 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`
+
+new_hostdev_xml = <<EOF
+<hostdev mode='subsystem' type='pci' managed='yes'>
+  <source>
+    <address bus='0x45' slot='0x55' function='0x33'/>
+  </source>
+</hostdev>
+EOF
+
+# start tests
+
+# TESTGROUP: conn.num_of_domains
+expect_too_many_args(conn, "num_of_domains", 1)
+expect_success(conn, "no args", "num_of_domains")
+
+# TESTGROUP: conn.list_domains
+expect_too_many_args(conn, "list_domains", 1)
+expect_success(conn, "no args", "list_domains")
+
+# 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")
+
+# TESTGROUP: conn.list_domains
+expect_too_many_args(conn, "list_defined_domains", 1)
+expect_success(conn, "no args", "list_defined_domains")
+
+# TESTGROUP: conn.create_domain_linux
+expect_too_many_args(conn, "create_domain_linux", new_dom_xml, 0, 1)
+expect_too_few_args(conn, "create_domain_linux")
+expect_invalid_arg_type(conn, "create_domain_linux", nil)
+expect_invalid_arg_type(conn, "create_domain_linux", 1)
+expect_invalid_arg_type(conn, "create_domain_linux", new_dom_xml, "foo")
+expect_fail(conn, Libvirt::Error, "invalid xml", "create_domain_linux", "hello")
+newdom = expect_success(conn, "domain xml", "create_domain_linux", new_dom_xml) {|x| x.class == Libvirt::Domain}
+sleep 1
+
+expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_linux", new_dom_xml)
+
+newdom.destroy
+
+# TESTGROUP: conn.create_domain_xml
+expect_too_many_args(conn, "create_domain_xml", new_dom_xml, 0, 1)
+expect_too_few_args(conn, "create_domain_xml")
+expect_invalid_arg_type(conn, "create_domain_xml", nil)
+expect_invalid_arg_type(conn, "create_domain_xml", 1)
+expect_invalid_arg_type(conn, "create_domain_xml", new_dom_xml, "foo")
+expect_fail(conn, Libvirt::Error, "invalid xml", "create_domain_xml", "hello")
+newdom = expect_success(conn, "domain xml", "create_domain_xml", new_dom_xml) {|x| x.class == Libvirt::Domain}
+sleep 1
+
+expect_fail(conn, Libvirt::Error, "already existing domain", "create_domain_xml", new_dom_xml)
+
+newdom.destroy
+
+# TESTGROUP: conn.lookup_domain_by_name
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(conn, "lookup_domain_by_name", 1, 2)
+expect_too_few_args(conn, "lookup_domain_by_name")
+expect_invalid_arg_type(conn, "lookup_domain_by_name", 1)
+expect_fail(conn, Libvirt::RetrieveError, "non-existent name arg", "lookup_domain_by_name", "foobarbazsucker")
+
+expect_success(conn, "name arg for running domain", "lookup_domain_by_name", "ruby-libvirt-tester") {|x| x.name == "ruby-libvirt-tester"}
+newdom.destroy
+
+newdom = conn.define_domain_xml(new_dom_xml)
+expect_success(conn, "name arg for defined domain", "lookup_domain_by_name", "ruby-libvirt-tester") {|x| x.name == "ruby-libvirt-tester"}
+newdom.undefine
+
+# TESTGROUP: conn.lookup_domain_by_id
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(conn, "lookup_domain_by_id", 1, 2)
+expect_too_few_args(conn, "lookup_domain_by_id")
+expect_invalid_arg_type(conn, "lookup_domain_by_id", "foo")
+expect_fail(conn, Libvirt::Error, "with negative value", "lookup_domain_by_id", -1)
+
+expect_success(conn, "id arg for running domain", "lookup_domain_by_id", newdom.id)
+newdom.destroy
+
+# TESTGROUP: conn.lookup_domain_by_uuid
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(conn, "lookup_domain_by_uuid", 1, 2)
+expect_too_few_args(conn, "lookup_domain_by_uuid")
+expect_invalid_arg_type(conn, "lookup_domain_by_uuid", 1)
+expect_fail(conn, Libvirt::RetrieveError, "invalid UUID", "lookup_domain_by_uuid", "abcd")
+
+expect_success(conn, "UUID arg for running domain", "lookup_domain_by_uuid", newdom.uuid) {|x| x.uuid == UUID}
+newdom.destroy
+
+newdom = conn.define_domain_xml(new_dom_xml)
+expect_success(conn, "UUID arg for defined domain", "lookup_domain_by_uuid", newdom.uuid) {|x| x.uuid == UUID}
+newdom.undefine
+
+# TESTGROUP: conn.define_domain_xml
+expect_too_many_args(conn, "define_domain_xml", 1, 2)
+expect_too_few_args(conn, "define_domain_xml")
+expect_invalid_arg_type(conn, "define_domain_xml", 1)
+expect_invalid_arg_type(conn, "define_domain_xml", nil)
+expect_fail(conn, Libvirt::DefinitionError, "invalid XML", "define_domain_xml", "hello")
+
+newdom = expect_success(conn, "domain xml arg", "define_domain_xml", new_dom_xml)
+newdom.undefine
+
+# TESTGROUP: conn.domain_xml_from_native
+expect_too_many_args(conn, "domain_xml_from_native", 1, 2, 3, 4)
+expect_too_few_args(conn, "domain_xml_from_native")
+expect_too_few_args(conn, "domain_xml_from_native", 1)
+expect_invalid_arg_type(conn, "domain_xml_from_native", 1, 2)
+expect_invalid_arg_type(conn, "domain_xml_from_native", nil, 2)
+expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", 2)
+expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", nil)
+expect_invalid_arg_type(conn, "domain_xml_from_native", "qemu-argv", "foo", "bar")
+expect_fail(conn, Libvirt::Error, "unsupported first arg", "domain_xml_from_native", "foo", "bar")
+
+expect_success(conn, "qemu-argv and qemu_cmd_line", "domain_xml_from_native", "qemu-argv", qemu_cmd_line)
+
+# TESTGROUP: conn.domain_xml_to_native
+expect_too_many_args(conn, "domain_xml_to_native", 1, 2, 3, 4)
+expect_too_few_args(conn, "domain_xml_to_native")
+expect_too_few_args(conn, "domain_xml_to_native", 1)
+expect_invalid_arg_type(conn, "domain_xml_to_native", 1, 2)
+expect_invalid_arg_type(conn, "domain_xml_to_native", nil, 2)
+expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", 2)
+expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", nil)
+expect_invalid_arg_type(conn, "domain_xml_to_native", "qemu-argv", "foo", "bar")
+expect_fail(conn, Libvirt::Error, "unsupported first arg", "domain_xml_to_native", "foo", "bar")
+
+expect_success(conn, "qemu-argv and domain XML", "domain_xml_to_native", "qemu-argv", new_dom_xml)
+
+# TESTGROUP: dom.migrate
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+dconn = Libvirt::open("qemu:///system")
+
+expect_too_many_args(newdom, "migrate", 1, 2, 3, 4, 5, 6)
+expect_too_few_args(newdom, "migrate")
+expect_fail(newdom, ArgumentError, "invalid connection object", "migrate", "foo")
+expect_invalid_arg_type(newdom, "migrate", dconn, 'foo')
+expect_invalid_arg_type(newdom, "migrate", dconn, 0, 1)
+expect_invalid_arg_type(newdom, "migrate", dconn, 0, 'foo', 1)
+expect_invalid_arg_type(newdom, "migrate", dconn, 0, 'foo', 'bar', 'baz')
+
+# FIXME: how can we make this work?
+#expect_success(newdom, "conn arg", "migrate", dconn)
+
+dconn.close
+
+newdom.destroy
+
+# TESTGROUP: dom.migrate_to_uri
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "migrate_to_uri", 1, 2, 3, 4, 5)
+expect_too_few_args(newdom, "migrate_to_uri")
+expect_invalid_arg_type(newdom, "migrate_to_uri", 1)
+expect_invalid_arg_type(newdom, "migrate_to_uri", "qemu:///system", 'foo')
+expect_invalid_arg_type(newdom, "migrate_to_uri", "qemu:///system", 0, 1)
+expect_invalid_arg_type(newdom, "migrate_to_uri", "qemu:///system", 0, 'foo', 'bar')
+
+#expect_success(newdom, "URI arg", "migrate_to_uri", "qemu://remote/system")
+
+dconn.close
+
+newdom.destroy
+
+# TESTGROUP: dom.migrate_set_max_downtime
 newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "migrate_set_max_downtime", 1, 2, 3)
+expect_too_few_args(newdom, "migrate_set_max_downtime")
+expect_invalid_arg_type(newdom, "migrate_set_max_downtime", 'foo')
+expect_invalid_arg_type(newdom, "migrate_set_max_downtime", 10, 'foo')
+expect_fail(newdom, Libvirt::Error, "on off domain", "migrate_set_max_downtime", 10)
+
 newdom.undefine
 
-`dd if=/dev/zero of=/var/lib/libvirt/images/ruby-libvirt-test.dsk bs=1 count=1 seek=5G`
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+expect_fail(newdom, Libvirt::Error, "while no migration in progress", "migrate_set_max_downtime", 10)
 
-newdom = conn.create_domain_linux(new_dom_xml)
-info = newdom.info
-if info.state != Libvirt::Domain::RUNNING
-  raise "Failed to start new domain"
+#newdom.migrate_to_uri("qemu://remote/system")
+#expect_success(newdom, "10 second downtime", "migrate_set_max_downtime", 10)
+
+newdom.destroy
+
+# TESTGROUP: dom.shutdown
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "shutdown", 1)
+expect_success(newdom, "no args", "shutdown")
+sleep 1
+newdom.destroy
+
+# TESTGROUP: dom.reboot
+newdom = conn.create_domain_xml(new_dom_xml)
+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
-sleep 2
+
+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_success(newdom, "no args", "destroy")
+
+# TESTGROUP: dom.suspend
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "suspend", 1)
+expect_success(newdom, "no args", "suspend")
+newdom.destroy
+
+# TESTGROUP: dom.resume
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_success(newdom, "no args running domain", "resume")
+
+newdom.suspend
+expect_too_many_args(newdom, "resume", 1)
+expect_success(newdom, "no args suspended domain", "resume")
+newdom.destroy
+
+# TESTGROUP: dom.save
 newdom = conn.define_domain_xml(new_dom_xml)
-info = newdom.info
 newdom.create
-sleep 2
-newdom.suspend
-sleep 2
-newdom.resume
-sleep 2
-#newdom.save('/var/lib/libvirt/images/ruby-libvirt-test.save')
-#sleep 2
-#newdom.restore
-ifinfo = newdom.ifinfo('rl556')
-puts "New Domain Interface Information rl556:"
-puts " rx_bytes:   #{ifinfo.rx_bytes}"
-puts " rx_packets: #{ifinfo.rx_packets}"
-puts " rx_errs:    #{ifinfo.rx_errs}"
-puts " rx_drop:    #{ifinfo.rx_drop}"
-puts " tx_bytes:   #{ifinfo.tx_bytes}"
-puts " tx_packets: #{ifinfo.tx_packets}"
-puts " tx_errs:    #{ifinfo.tx_errs}"
-puts " tx_drop:    #{ifinfo.tx_drop}"
-seclabel = newdom.security_label
-puts "New Domain Security Label:"
-puts " Label:     #{seclabel.label}"
-puts " Enforcing: #{seclabel.enforcing}"
-blockstat = newdom.block_stats('vda')
-puts "New Domain Block Stats vda:"
-puts " rd_req: #{blockstat.rd_req}"
-puts " rd_bytes: #{blockstat.rd_bytes}"
-puts " wr_req: #{blockstat.wr_req}"
-puts " wr_bytes: #{blockstat.wr_bytes}"
-puts " errs: #{blockstat.errs}"
-memstat = newdom.memory_stats
-memstat = newdom.memory_stats(0)
-puts "New Domain Memory Stats:"
-memstat.each do |stat|
-  puts " #{stat.tag}: #{stat.val}"
+sleep 1
+
+expect_too_many_args(newdom, "save", 1, 2)
+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")
+
+`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
+newdom.undefine
+
+# TESTGROUP: dom.managed_save
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.create
+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
+
+# TESTGROUP: dom.has_managed_save?
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.create
+sleep 1
+
+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"
+else
+  puts_ok "dom.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"
+else
+  puts_ok "dom.has_managed_save? reports true after a managed save"
+end
+
+newdom.undefine
+
+# TESTGROUP: dom.managed_save_remove
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.create
+sleep 1
+newdom.managed_save
+
+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"
+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"
+else
+  puts_ok "after dom.managed_save_remove, managed save file no longer exists"
+end
+
+newdom.undefine
+
+# TESTGROUP: dom.core_dump
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.create
+sleep 1
+
+expect_too_many_args(newdom, "core_dump", 1, 2, 3)
+expect_too_few_args(newdom, "core_dump")
+expect_invalid_arg_type(newdom, "core_dump", 1, 2)
+expect_invalid_arg_type(newdom, "core_dump", "/path", "foo")
+expect_fail(newdom, Libvirt::Error, "invalid path", "core_dump", "/this/path/does/not/exist")
+
+expect_success(newdom, "live with path arg", "core_dump", "/var/lib/libvirt/images/ruby-libvirt-test.core")
+
+`rm -f /var/lib/libvirt/images/ruby-libvirt-test.core`
+
+expect_success(newdom, "crash with path arg", "core_dump", "/var/lib/libvirt/images/ruby-libvirt-test.core", Libvirt::Domain::DUMP_CRASH)
+
+expect_fail(newdom, Libvirt::Error, "of shut-off domain", "core_dump", "/var/lib/libvirt/images/ruby-libvirt-test.core", Libvirt::Domain::DUMP_CRASH)
+
+`rm -f /var/lib/libvirt/images/ruby-libvirt-test.core`
+
+newdom.undefine
+
+# TESTGROUP: Libvirt::Domain::restore
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.create
+sleep 1
+newdom.save("/var/lib/libvirt/images/ruby-libvirt-test.save")
+
+expect_too_many_args(Libvirt::Domain, "restore", 1, 2, 3)
+expect_too_few_args(Libvirt::Domain, "restore")
+expect_invalid_arg_type(Libvirt::Domain, "restore", 1, 2)
+expect_invalid_arg_type(Libvirt::Domain, "restore", conn, 2)
+expect_fail(Libvirt::Domain, Libvirt::Error, "invalid path", "restore", conn, "/this/path/does/not/exist")
+`touch /tmp/foo`
+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")
+
+`rm -f /var/lib/libvirt/images/ruby-libvirt-test.save`
+
+newdom.destroy
+newdom.undefine
+
+# TESTGROUP: dom.info
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "info", 1)
+
+expect_success(newdom, "no args", "info") {|x| x.state == Libvirt::Domain::RUNNING and x.max_mem == 1048576 and x.memory == 1048576 and x.nr_virt_cpu == 2}
+
+newdom.destroy
+
+# TESTGROUP: dom.security_label
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "security_label", 1)
+
+expect_success(newdom, "no args", "security_label")
+
+newdom.destroy
+
+# TESTGROUP: dom.block_stats
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "block_stats", 1, 2)
+expect_too_few_args(newdom, "block_stats")
+expect_invalid_arg_type(newdom, "block_stats", 1)
+expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "block_stats", "foo")
+
+expect_success(newdom, "block device arg", "block_stats", "vda")
+
+newdom.destroy
+
+# TESTGROUP: dom.memory_stats
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "memory_stats", 1, 2)
+expect_invalid_arg_type(newdom, "memory_stats", "foo")
+
+expect_success(newdom, "no args", "memory_stats")
+
+newdom.destroy
+
+# TESTGROUP: dom.blockinfo
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "blockinfo", 1, 2, 3)
+expect_too_few_args(newdom, "blockinfo")
+expect_invalid_arg_type(newdom, "blockinfo", 1)
+expect_invalid_arg_type(newdom, "blockinfo", "foo", "bar")
+expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "blockinfo", "foo")
+
+expect_success(newdom, "path arg", "blockinfo", GUEST_DISK)
+
+newdom.destroy
+
+# TESTGROUP: dom.block_peek
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "block_peek", 1, 2, 3, 4, 5)
+expect_too_few_args(newdom, "block_peek")
+expect_too_few_args(newdom, "block_peek", 1)
+expect_too_few_args(newdom, "block_peek", 1, 2)
+expect_invalid_arg_type(newdom, "block_peek", 1, 2, 3)
+expect_invalid_arg_type(newdom, "block_peek", "foo", "bar", 3)
+expect_invalid_arg_type(newdom, "block_peek", "foo", 0, "bar")
+expect_invalid_arg_type(newdom, "block_peek", "foo", 0, 512, "baz")
+expect_fail(newdom, Libvirt::RetrieveError, "invalid path", "block_peek", "foo", 0, 512)
+
+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"
+else
+  puts_ok "dom.block_peek read valid data"
+end
+
+newdom.destroy
+
+# TESTGROUP: dom.memory_peek
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "memory_peek", 1, 2, 3, 4)
+expect_too_few_args(newdom, "memory_peek")
+expect_too_few_args(newdom, "memory_peek", 1)
+expect_invalid_arg_type(newdom, "memory_peek", "foo", 2)
+expect_invalid_arg_type(newdom, "memory_peek", 0, "bar")
+expect_invalid_arg_type(newdom, "memory_peek", 0, 512, "baz")
+
+expect_success(newdom, "offset and size args", "memory_peek", 0, 512)
+puts_ok "dom.memory_peek succeeded"
+
+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.destroy
+
+# TESTGROUP: dom.active?
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "active?", 1)
+
+expect_success(newdom, "no args", "active?") {|x| x == true}
+
+newdom.destroy
+
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_success(newdom, "no args", "active?") {|x| x == false}
+
+newdom.create
+sleep 1
+
+expect_success(newdom, "no args", "active?") {|x| x == true}
+
+newdom.destroy
+newdom.undefine
+
+# TESTGROUP: dom.persistent?
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "persistent?", 1)
+
+expect_success(newdom, "no args", "persistent?") {|x| x == false}
+
+newdom.destroy
+
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_success(newdom, "no args", "persistent?") {|x| x == true}
+
+newdom.undefine
+
+# TESTGROUP: dom.ifinfo
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "ifinfo", 1, 2)
+expect_too_few_args(newdom, "ifinfo")
+expect_invalid_arg_type(newdom, "ifinfo", 1)
+expect_fail(newdom, Libvirt::RetrieveError, "invalid arg", "ifinfo", "foo")
+
+expect_success(newdom, "interface arg", "ifinfo", "rl556")
+
+newdom.destroy
+
+# TESTGROUP: dom.name
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "name", 1)
+
+expect_success(newdom, "no args", "name") {|x| x == "ruby-libvirt-tester"}
+
+newdom.destroy
+
+# TESTGROUP: dom.id
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "id", 1)
+
+expect_success(newdom, "no args", "id")
+
+newdom.destroy
+
+# TESTGROUP: dom.uuid
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "uuid", 1)
+
+expect_success(newdom, "no args", "uuid") {|x| x == UUID}
+
+newdom.destroy
+
+# TESTGROUP: dom.os_type
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "os_type", 1)
+
+expect_success(newdom, "no args", "os_type") {|x| x == "hvm"}
+
+newdom.destroy
+
+# TESTGROUP: dom.max_memory
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "max_memory", 1)
+
+expect_success(newdom, "no args", "max_memory") {|x| x == 1048576}
+
+newdom.destroy
+
+# TESTGROUP: dom.max_memory=
+newdom = conn.define_domain_xml(new_dom_xml)
+
+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
+
+newdom.undefine
+
+# TESTGROUP: dom.memory=
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "memory=", 1, 2)
+expect_too_few_args(newdom, "memory=")
+expect_invalid_arg_type(newdom, "memory=", 'foo')
+
+expect_fail(newdom, Libvirt::Error, "shutoff domain", "memory=", 2)
+
+newdom.undefine
+
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_success(newdom, "number arg", "memory=", 200000)
+
+newdom.destroy
+
+# TESTGROUP: dom.max_vcpus
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "max_vcpus", 1)
+
+expect_success(newdom, "no args", "max_vcpus")
+
+newdom.destroy
+
+# TESTGROUP: dom.vcpus=
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "vcpus=", 1, 2)
+expect_too_few_args(newdom, "vcpus=")
+expect_invalid_arg_type(newdom, "vcpus=", 'foo')
+
+expect_fail(newdom, Libvirt::Error, "shutoff domain", "vcpus=", 2)
+
+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)
+
+newdom.destroy
+
+# TESTGROUP: dom.pin_vcpu
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "pin_vcpu", 1, 2, 3)
+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)
+
+expect_success(newdom, "cpu args", "pin_vcpu", 0, [0])
+
+newdom.destroy
+
+# TESTGROUP: dom.xml_desc
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_too_many_args(newdom, "xml_desc", 1, 2)
+expect_invalid_arg_type(newdom, "xml_desc", "foo")
+
+expect_success(newdom, "no args", "xml_desc")
+
+newdom.destroy
+
+# TESTGROUP: dom.undefine
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "undefine", 1)
+
+expect_success(newdom, "no args", "undefine")
+
+# TESTGROUP: dom.create
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "create", 1, 2)
+expect_invalid_arg_type(newdom, "create", "foo")
+
+expect_success(newdom, "no args", "create")
+
+expect_fail(newdom, Libvirt::Error, "on already running domain", "create")
+
+newdom.destroy
+newdom.undefine
+
+# TESTGROUP: dom.autostart?
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "autostart?", 1)
+
+expect_success(newdom, "no args", "autostart?") {|x| x == false}
+
+newdom.autostart = true
+
+expect_success(newdom, "no args", "autostart?") {|x| x == true}
+
+newdom.undefine
+
+# TESTGROUP: dom.autostart=
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "autostart=", 1, 2)
+expect_invalid_arg_type(newdom, "autostart=", 'foo')
+expect_invalid_arg_type(newdom, "autostart=", nil)
+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"
+else
+  puts_ok "dom.autostart= set autostart to true"
 end
-blockinfo = newdom.blockinfo('/var/lib/libvirt/images/ruby-libvirt-test.dsk')
-blockinfo = newdom.blockinfo('/var/lib/libvirt/images/ruby-libvirt-test.dsk', 0)
-puts "New Domain Block Info vda:"
-puts " Capacity:   #{blockinfo.capacity}"
-puts " Allocation: #{blockinfo.allocation}"
-puts " Physical:   #{blockinfo.physical}"
-blockpeek = newdom.block_peek('/var/lib/libvirt/images/ruby-libvirt-test.dsk',
-                              0, 512)
-blockpeek = newdom.block_peek('/var/lib/libvirt/images/ruby-libvirt-test.dsk',
-                              0, 512, 0)
-# 2010-06-30: memory_peek is broken on RHEL-6 libvirt; fixed in upstream
-#mempeek = newdom.memory_peek(0, 512, Libvirt::Domain::MEMORY_VIRTUAL)
-
-
-defined = conn.list_defined_domains
-running = conn.list_domains
-
-(defined+running).each do |dom|
-  if defined.include? dom
-    domain = conn.lookup_domain_by_name(dom)
-  elsif running.include? dom
-    domain = conn.lookup_domain_by_id(dom)
-  end
-  dom2 = conn.lookup_domain_by_uuid(domain.uuid)
-  puts "Domain #{domain.name}:"
-  puts " UUID:        #{domain.uuid}"
-  puts " ID:          #{domain.id}"
-  puts " OS Type:     #{domain.os_type}"
-  puts " Max Memory:  #{domain.max_memory}"
-  puts " Max VCPUs:   #{domain.max_vcpus}"
-  puts " Persistent?: #{domain.persistent?}"
-  puts " Active?:     #{domain.active?}"
-  info = domain.info
-  puts " Info:"
-  puts "  State:        #{info.state}"
-  puts "  Max Memory:   #{info.max_mem}"
-  puts "  Memory:       #{info.memory}"
-  puts "  Number VCPUs: #{info.nr_virt_cpu}"
-  puts "  CPU Time:     #{info.cpu_time}"
-  puts " Snapshots:"
-  puts "  Number: #{domain.num_of_snapshots}"
-  puts "  Has Current?: #{domain.has_current_snapshot?}"
-  domain.list_snapshots.each do |snapname|
-    snap = domain.lookup_snapshot_by_name(snapname)
-    puts "  Snapshot #{snapname}"
-    puts snap.xml_desc
-  end
-  domain.xml_desc
-  puts " XML:"
-  puts domain.xml_desc(0)
+
+expect_success(newdom, "false arg", "autostart=", false)
+if newdom.autostart?
+  puts_fail "dom.autostart= did not set autostart to false"
+else
+  puts_ok "dom.autostart= set autostart to false"
 end
 
+newdom.undefine
+
+# TESTGROUP: dom.attach_device
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "attach_device", 1, 2, 3)
+expect_too_few_args(newdom, "attach_device")
+expect_invalid_arg_type(newdom, "attach_device", 1)
+expect_invalid_arg_type(newdom, "attach_device", 'foo', 'bar')
+expect_fail(newdom, Libvirt::Error, "invalid XML", "attach_device", "hello")
+expect_fail(newdom, Libvirt::Error, "shut off domain", "attach_device", new_hostdev_xml)
+
+newdom.undefine
+
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+#expect_success(newdom, "hostdev XML", "attach_device", new_hostdev_xml)
+
 newdom.destroy
+
+# TESTGROUP: dom.detach_device
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "detach_device", 1, 2, 3)
+expect_too_few_args(newdom, "detach_device")
+expect_invalid_arg_type(newdom, "detach_device", 1)
+expect_invalid_arg_type(newdom, "detach_device", 'foo', 'bar')
+expect_fail(newdom, Libvirt::Error, "invalid XML", "detach_device", "hello")
+expect_fail(newdom, Libvirt::Error, "shut off domain", "detach_device", new_hostdev_xml)
+
 newdom.undefine
 
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+#expect_success(newdom, "hostdev XML", "detach_device", new_hostdev_xml)
+
+newdom.destroy
+
+# TESTGROUP: dom.update_device
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "update_device", 1, 2, 3)
+expect_too_few_args(newdom, "update_device")
+expect_invalid_arg_type(newdom, "update_device", 1)
+expect_invalid_arg_type(newdom, "update_device", 'foo', 'bar')
+expect_fail(newdom, Libvirt::Error, "invalid XML", "update_device", "hello")
+expect_fail(newdom, Libvirt::Error, "shut off domain", "update_device", new_hostdev_xml)
+
+newdom.undefine
+
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+#expect_success(newdom, "hostdev XML", "update_device", new_hostdev_xml)
+
+newdom.destroy
+
+# TESTGROUP: dom.free
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.undefine
+expect_too_many_args(newdom, "free", 1)
+
+newdom.free
+puts_ok "dom.free succeeded"
+
+# TESTGROUP: dom.snapshot_create_xml
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "snapshot_create_xml", 1, 2, 3)
+expect_too_few_args(newdom, "snapshot_create_xml")
+expect_invalid_arg_type(newdom, "snapshot_create_xml", 1)
+expect_invalid_arg_type(newdom, "snapshot_create_xml", nil)
+expect_invalid_arg_type(newdom, "snapshot_create_xml", 'foo', 'bar')
+
+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"
+else
+  puts_ok "dom.snapshot_create_xml after one snapshot has 1 snapshot"
+end
+
+newdom.undefine
+
+# TESTGROUP: dom.num_of_snapshots
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "num_of_snapshots", 1, 2)
+expect_invalid_arg_type(newdom, "num_of_snapshots", 'foo')
+
+expect_success(newdom, "no args", "num_of_snapshots") {|x| x == 0}
+
+newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_success(newdom, "no args", "num_of_snapshots") {|x| x == 1}
+
+newdom.undefine
+
+# TESTGROUP: dom.list_snapshots
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "list_snapshots", 1, 2)
+expect_invalid_arg_type(newdom, "list_snapshots", 'foo')
+
+expect_success(newdom, "no args", "list_snapshots") {|x| x.length == 0}
+
+newdom.snapshot_create_xml("<domainsnapshot/>")
+
+expect_success(newdom, "no args", "list_snapshots") {|x| x.length == 1}
+
+newdom.undefine
+
+# TESTGROUP: dom.lookup_snapshot_by_name
+newdom = conn.define_domain_xml(new_dom_xml)
+newdom.snapshot_create_xml("<domainsnapshot><name>foo</name></domainsnapshot>")
+
+expect_too_many_args(newdom, "lookup_snapshot_by_name", 1, 2, 3)
+expect_too_few_args(newdom, "lookup_snapshot_by_name")
+expect_invalid_arg_type(newdom, "lookup_snapshot_by_name", 1)
+expect_invalid_arg_type(newdom, "lookup_snapshot_by_name", 'foo', 'bar')
+
+expect_success(newdom, "name arg", "lookup_snapshot_by_name", "foo")
+
+newdom.undefine
+
+# TESTGROUP: dom.has_current_snapshot?
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "has_current_snapshot?", 1, 2)
+expect_invalid_arg_type(newdom, "has_current_snapshot?", 'foo')
+
+expect_success(newdom, "no args", "has_current_snapshot?") {|x| x == false}
+
+newdom.snapshot_create_xml("<domainsnapshot><name>foo</name></domainsnapshot>")
+
+expect_success(newdom, "no args", "has_current_snapshot?") {|x| x == true}
+
+newdom.undefine
+
+# TESTGROUP: dom.revert_to_snapshot
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "revert_to_snapshot", 1, 2, 3)
+expect_too_few_args(newdom, "revert_to_snapshot")
+expect_invalid_arg_type(newdom, "revert_to_snapshot", 1)
+expect_invalid_arg_type(newdom, "revert_to_snapshot", nil)
+expect_invalid_arg_type(newdom, "revert_to_snapshot", 'foo')
+
+snap = newdom.snapshot_create_xml("<domainsnapshot><name>foo</name></domainsnapshot>")
+sleep 1
+
+expect_invalid_arg_type(newdom, "revert_to_snapshot", snap, 'foo')
+
+expect_success(newdom, "snapshot arg", "revert_to_snapshot", snap)
+
+newdom.undefine
+
+# TESTGROUP: dom.current_snapshot
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "current_snapshot", 1, 2)
+expect_invalid_arg_type(newdom, "current_snapshot", 'foo')
+expect_fail(newdom, Libvirt::RetrieveError, "with no snapshots", "current_snapshot")
+
+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")
+
+# TESTGROUP: dom.job_info
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "job_info", 1)
+
+expect_fail(newdom, Libvirt::RetrieveError, "shutoff domain", "job_info")
+
+newdom.undefine
+
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_success(newdom, "no args", "job_info")
+
+newdom.destroy
+
+# TESTGROUP: dom.abort_job
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "abort_job", 1)
+
+expect_fail(newdom, Libvirt::Error, "not running domain", "abort_job")
+
+newdom.undefine
+
+newdom = conn.create_domain_xml(new_dom_xml)
+sleep 1
+
+expect_fail(newdom, Libvirt::Error, "no active job", "abort_job")
+
+# FIXME: need to start long running job here
+#expect_success(newdom, "no args", "abort_job")
+
+newdom.destroy
+
+# TESTGROUP: dom.scheduler_type
+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
+
+newdom.undefine
+
+# TESTGROUP: dom.scheduler_parameters
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "scheduler_parameters", 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
+
+newdom.undefine
+
+# TESTGROUP: dom.scheduler_parameters=
+newdom = conn.define_domain_xml(new_dom_xml)
+
+expect_too_many_args(newdom, "scheduler_parameters=", 1, 2)
+expect_too_few_args(newdom, "scheduler_parameters=")
+expect_invalid_arg_type(newdom, "scheduler_parameters=", 0)
+
+# FIXME: set scheduler_parameters here
+
+newdom.undefine
+
+# TESTGROUP: dom.num_vcpus
+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}
+
+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_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
+
 conn.close
+
+finish_tests