virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/com/ffi/util_test.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class COMFFIUtilTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::FFI::Util
+  end
+
+  context "converting function specs to FFI parameter lists" do
+    def assert_spec(spec, expected)
+      result = @klass.spec_to_ffi(spec)
+      result.shift
+      assert_equal expected, result
+    end
+
+    should "leaving primitives alone" do
+      assert_spec([:int], [:int])
+    end
+
+    should "convert any out parameters to pointers" do
+      assert_spec([[:out, :int]], [:pointer])
+    end
+
+    should "convert unicode strings to pointers" do
+      assert_spec([:unicode_string], [:pointer])
+    end
+
+    should "convert COM interfaces to pointers" do
+      assert_spec([:VirtualBox], [:pointer])
+    end
+
+    should "convert enums to ints" do
+      assert_spec([:FirmwareType], [VirtualBox::COM::T_UINT32])
+    end
+
+    should "convert unknown classes to pointers" do
+      assert_spec([:VirtualBoxFoo], [:pointer])
+    end
+
+    should "convert array parameters to two params" do
+      assert_spec([[:unicode_string]], [VirtualBox::COM::T_UINT32, :pointer])
+    end
+
+    should "add a pointer at the beginning for the `this` parameter" do
+      assert_equal [:pointer], @klass.spec_to_ffi([])
+    end
+
+    should "turn arrays into multiple pointers (one for size and one for the array)" do
+      assert_spec([[:out, [:int]]], [:pointer, :pointer])
+    end
+  end
+
+  context "camelizing" do
+    should "camel case strings" do
+      tests = {
+        "foo_bar" => "FooBar",
+        "foobar" => "Foobar",
+        # Special cases below
+        "guest_os_type" => "GuestOSType",
+        "dhcp_servers" => "DHCPServers",
+        "dvd_images" => "DVDImages",
+        "usb_devices" => "USBDevices",
+        "ram_size" => "RAMSize",
+        "vram_size" => "VRAMSize",
+        "accelerate_3d_enabled" => "Accelerate3DEnabled",
+        "bios_settings" => "BIOSSettings",
+        "vrdp_server" => "VRDPServer",
+        "get_hw_virt_ex_property" => "GetHWVirtExProperty",
+        "query_saved_screenshot_png_size" => "QuerySavedScreenshotPNGSize",
+        "acpi_enabled" => "ACPIEnabled",
+        "io_apic_enabled" => "IOAPICEnabled",
+        "pxe_debug_enabled" => "PXEDebugEnabled",
+        "nat_foo" => "NATFoo",
+        "ide_emulation" => "IDEEmulation",
+        "create_vfs_explorer" => "CreateVFSExplorer",
+        "ip_address" => "IPAddress",
+        "max_vdi_size" => "MaxVDISize",
+        "cpu_count" => "CPUCount",
+        "recommended_hdd" => "RecommendedHDD"
+      }
+
+      tests.each do |arg, expected|
+        assert_equal expected, @klass.camelize(arg)
+      end
+    end
+  end
+end

data/test/virtualbox/com/ffi_interface_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class COMFFIInterfaceBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::FFIInterface
+  end
+
+  context "class methods" do
+    context "setting up" do
+      should "set the ffi lib to the given path then attach function" do
+        lib = :foo
+
+        setup_seq = sequence('setup_seq')
+        @klass.expects(:ffi_lib).with(lib).in_sequence(setup_seq)
+        @klass.expects(:attach_function).with(:VBoxGetXPCOMCFunctions, anything, anything).in_sequence(setup_seq)
+        @klass.setup(lib)
+      end
+    end
+
+    context "creating" do
+      should "setup the initialize" do
+        lib = :foo
+        result = mock("result")
+        create_seq = sequence("create_seq")
+        @klass.expects(:setup).with(lib).in_sequence(create_seq)
+        @klass.expects(:new).returns(result).in_sequence(create_seq)
+        assert_equal result, @klass.create(lib)
+      end
+    end
+  end
+
+  context "initialization" do
+    should "initialize com interface" do
+      @klass.any_instance.expects(:initialize_com).once
+      @klass.new
+    end
+  end
+
+  context "initializing com interface" do
+    # TODO
+  end
+end

data/test/virtualbox/com/implementer/base_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class COMImplementerBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::Implementer::Base
+    @interface = mock("interface")
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new(@interface)
+    end
+
+    context "inferring types" do
+      should "return the proper values" do
+        expectations = {
+          :int => [:int, :int],
+          :unicode_string => [:pointer, :unicode_string],
+          :Host => [:pointer, :interface]
+        }
+
+        expectations.each do |original, result|
+          assert_equal result, @instance.infer_type(original)
+        end
+      end
+    end
+
+    context "getting an interface class" do
+      should "get from COM::Interface and return" do
+        result = mock("result")
+        type_name = :foo
+        VirtualBox::COM::Interface.expects(:const_get).with(type_name).returns(result)
+        assert_equal result, @instance.interface_klass(type_name)
+      end
+    end
+  end
+end

data/test/virtualbox/com/implementer/ffi_test.rb

@@ -0,0 +1,519 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class COMImplementerFFITest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::Implementer::FFI
+  end
+
+  context "initializing" do
+    setup do
+      @interface = mock("interface")
+      @interface.stubs(:class).returns(VirtualBox::COM::Interface::Session)
+
+      @ffi = mock("ffi")
+
+      @pointer = mock("pointer")
+    end
+
+    should "initialize the FFI interface associated with the AbstractInterface" do
+      result = mock("result")
+      VirtualBox::COM::FFI::Session.expects(:new).with(@pointer).once.returns(result)
+      instance = @klass.new(@interface, @ffi, @pointer)
+      assert_equal result, instance.ffi_interface
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @lib_base = mock("lib_base")
+      @ffi_interface = mock("ffi_interface")
+      @ffi_class = mock("ffi_class")
+      @pointer = mock("pointer")
+
+      @ffi_class.stubs(:new).returns(@ffi_interface)
+      @klass.any_instance.stubs(:ffi_class).returns(@ffi_class)
+
+      @instance = @klass.new(@interface, @lib_base, @pointer)
+    end
+
+    context "reading a property" do
+      should "call call_vtbl_function with the proper arguments" do
+        @instance.expects(:call_vtbl_function).with(:get_foo, [[:out, :bar]])
+        @instance.read_property(:foo, { :value_type => :bar })
+      end
+    end
+
+    context "writing a property" do
+      should "call call_vtbl_function with the proper arguments" do
+        @instance.expects(:call_vtbl_function).with(:set_foo, [:bar], [7])
+        @instance.write_property(:foo, 7, { :value_type => :bar })
+      end
+    end
+
+    context "calling a function" do
+      should "call call_vtbl_function with the proper arguments" do
+        @instance.expects(:call_vtbl_function).with(:say_hello, [:int, [:out, :string]], [1, 2, 3])
+        @instance.call_function(:say_hello, [1, 2, 3], {
+          :value_type => :string,
+          :spec => [:int]
+        })
+      end
+    end
+
+    context "calling a vtbl function" do
+      setup do
+        @vtbl = mock("vtbl")
+        @vtbl_parent = mock("vtbl_parent")
+        @ffi_interface.stubs(:vtbl).returns(@vtbl)
+        @ffi_interface.stubs(:vtbl_parent).returns(@vtbl_parent)
+
+        @proc = mock("proc")
+
+        @name = :foo
+        @spec = [:bar]
+        @args = [:baz]
+      end
+
+      should "pass in the formal args then return the values from them" do
+        result = mock("result")
+        @formal = [:foo]
+
+        @instance.expects(:spec_to_args).with(@spec, @args).returns(@formal)
+        @vtbl.expects(:[]).with(@name).returns(@proc)
+        @instance.expects(:call_and_check).with(@proc, @vtbl_parent, *@formal)
+        @instance.expects(:values_from_formal_args).with(@spec, @formal).returns(result)
+        assert_equal result, @instance.call_vtbl_function(@name, @spec, @args)
+      end
+    end
+
+    context "function calling and error checking" do
+      setup do
+        @function = mock("function")
+        @function.stubs(:call).returns(0)
+      end
+
+      should "raise an exception if an error occurred" do
+        @function.expects(:call).returns(0x8000_4002)
+        assert_raises(VirtualBox::Exceptions::FFIException) {
+          @instance.call_and_check(@function)
+        }
+      end
+
+      should "not raise an exception if an error did not occur" do
+        @function.expects(:call).returns(0x0000_0000)
+        assert_nothing_raised {
+          @instance.call_and_check(@function)
+        }
+      end
+
+      should "not raise an exception for NS_ERROR_NOT_IMPLEMENTED" do
+        @function.expects(:call).returns(0x8000_4001)
+        assert_nothing_raised {
+          @instance.call_and_check(@function)
+        }
+      end
+
+      should "forward arguments" do
+        @function.expects(:call).with(1,2,3).returns(0)
+        assert_nothing_raised {
+          @instance.call_and_check(@function, 1, 2, 3)
+        }
+      end
+    end
+
+    context "result code mapping" do
+      should "return a mapped exception object if it exists" do
+        assert_equal VirtualBox::Exceptions::ObjectNotFoundException, @instance.exception_map(0x80BB_0001)
+      end
+
+      should "return FFIException if no mapping is found" do
+        assert_equal VirtualBox::Exceptions::FFIException, @instance.exception_map(-5)
+      end
+    end
+
+    context "spec to formal argument list" do
+      setup do
+        @pointer = mock("pointer")
+        @instance.stubs(:pointer_for_type).returns(@pointer)
+      end
+
+      should "replace primitives with their types" do
+        assert_equal [7], @instance.spec_to_args([:int], [7])
+      end
+
+      should "replace booleans with 1/0" do
+        bool = VirtualBox::COM::T_BOOL
+        assert_equal [1,0], @instance.spec_to_args([bool, bool], [true, false])
+      end
+
+      should "replace single out items with a pointer" do
+        @instance.expects(:pointer_for_type).with(:foo).returns(@pointer)
+        assert_equal [@pointer], @instance.spec_to_args([[:out, :foo]])
+      end
+
+      should "convert Ruby strings into unicode strings" do
+        spec = [VirtualBox::COM::WSTRING]
+        args = ["foo"]
+
+        @instance.expects(:string_to_utf16).with(args[0]).returns("bar")
+        assert_equal ["bar"], @instance.spec_to_args(spec, args)
+      end
+
+      should "convert interfaces with nil arguments to nil" do
+        spec = [:Machine]
+        args = [nil]
+
+        assert_equal [nil], @instance.spec_to_args(spec, args)
+      end
+
+      should "convert enums to their property indices" do
+        spec = [:FirmwareType]
+        args = [:efi]
+
+        assert_equal [1], @instance.spec_to_args(spec, args)
+      end
+
+      should "replace array types with two parameters" do
+        @counter_pointer = mock("count_pointer")
+        @pointer = mock("pointer")
+
+        @instance.expects(:pointer_for_type).with(VirtualBox::COM::T_UINT32).returns(@count_pointer)
+        @instance.expects(:pointer_for_type).with(:foo).returns(@pointer)
+        assert_equal [@count_pointer, @pointer], @instance.spec_to_args([[:out, [:foo]]])
+      end
+    end
+
+    context "values from a formal parameter list" do
+      should "return nil if there are no output parameters" do
+        spec = []
+        formal = []
+
+        assert_nil @instance.values_from_formal_args(spec, formal)
+      end
+
+      should "dereference the pointer with proper type" do
+        pointer = mock("pointer")
+        spec = [[:out, :foo]]
+        formal = [pointer]
+
+        result = mock("result")
+        @instance.expects(:dereference_pointer).with(pointer, :foo).once.returns(result)
+        assert_equal result, @instance.values_from_formal_args(spec, formal)
+      end
+
+      should "dereference the array pointer with the proper type" do
+        count_pointer = mock("count_pointer")
+        pointer = mock("pointer")
+        count = mock("count")
+        result = mock("result")
+        spec = [[:out, [:foo]]]
+        formal = [count_pointer, pointer]
+
+        @instance.expects(:dereference_pointer).with(count_pointer, VirtualBox::COM::T_UINT32).returns(count)
+        @instance.expects(:dereference_pointer_array).with(pointer, :foo, count).returns(result)
+        assert_equal result, @instance.values_from_formal_args(spec, formal)
+      end
+
+      should "return an array for multiple values" do
+        spec = [:int, [:out, :foo], [:out, :bar]]
+        formal = [1,2,3]
+
+        result = mock("result")
+        @instance.stubs(:dereference_pointer).returns(result)
+        assert_equal [result, result], @instance.values_from_formal_args(spec, formal)
+      end
+    end
+
+    context "pointers for type" do
+      setup do
+        @pointer = mock("pointer")
+        FFI::MemoryPointer.stubs(:new).returns(@pointer)
+      end
+
+      should "create a pointer type for the given type" do
+        @instance.expects(:infer_type).with(:MyType).returns([:pointer, :struct])
+        FFI::MemoryPointer.expects(:new).with(:pointer).once.returns(@pointer)
+        @instance.pointer_for_type(:MyType) do |ptr, type|
+          assert_equal :struct, type
+        end
+      end
+
+      should "return the result of the yield" do
+        expected = mock("result")
+        result = @instance.pointer_for_type(:int) do |ptr, type|
+          expected
+        end
+
+        assert_equal expected, result
+      end
+
+      should "return the pointer if no block is given" do
+        assert_equal @pointer, @instance.pointer_for_type(:int)
+      end
+    end
+
+    context "dereferencing pointers" do
+      setup do
+        @pointer = mock('pointer')
+        @pointer.stubs(:respond_to?).returns(true)
+        @pointer.stubs(:get_bar).returns("foo")
+
+        @type = :zoo
+
+        @c_type = :foo
+        @inferred_type = :bar
+        @instance.stubs(:infer_type).returns([@c_type, @inferred_type])
+      end
+
+      should "infer the type" do
+        @instance.expects(:infer_type).with(@type).returns([@c_type, @inferred_type])
+        @instance.dereference_pointer(@pointer, @type)
+      end
+
+      should "call get_* method on pointer if it exists" do
+        result = mock("result")
+        @pointer.expects(:respond_to?).with("get_#{@inferred_type}".to_sym).returns(true)
+        @pointer.expects("get_#{@inferred_type}".to_sym).with(0).returns(result)
+        assert_equal result, @instance.dereference_pointer(@pointer, @type)
+      end
+
+      should "return a false bool if type is bool and failure" do
+        @pointer.expects(:get_bar).returns(0)
+        result = @instance.dereference_pointer(@pointer, VirtualBox::COM::T_BOOL)
+        assert_equal false, result
+      end
+
+      should "return a true bool if type is bool and success" do
+        @pointer.expects(:get_bar).returns(1)
+        result = @instance.dereference_pointer(@pointer, VirtualBox::COM::T_BOOL)
+        assert_equal true, result
+      end
+
+      should "call read_* on Util if pointer doesn't support it" do
+        result = mock("result")
+        @pointer.expects(:respond_to?).with("get_#{@inferred_type}".to_sym).returns(false)
+        @instance.expects("read_#{@inferred_type}".to_sym).with(@pointer, @type).returns(result)
+        assert_equal result, @instance.dereference_pointer(@pointer, @type)
+      end
+    end
+
+    context "dereferencing pointer array" do
+      setup do
+        @array_pointer = mock('array_pointer')
+        @array_pointer.stubs(:respond_to?).returns(true)
+        @array_pointer.stubs(:get_array_of_bar)
+
+        @pointer = mock('pointer')
+        @pointer.stubs(:get_pointer).with(0).returns(@array_pointer)
+
+        @type = :zoo
+        @length = 3
+
+        @c_type = :foo
+        @inferred_type = :bar
+        @instance.stubs(:infer_type).returns([@c_type, @inferred_type])
+      end
+
+      should "infer the type" do
+        @instance.expects(:infer_type).with(@type).returns([@c_type, @inferred_type])
+        @instance.dereference_pointer_array(@pointer, @type, @length)
+      end
+
+      should "return an empty array if count is zero" do
+        assert_equal [], @instance.dereference_pointer_array(@pointer, @type, 0)
+      end
+
+      should "call get_* method on array pointer if it exists" do
+        result = mock("result")
+        @array_pointer.expects(:respond_to?).with("get_array_of_#{@inferred_type}".to_sym).returns(true)
+        @array_pointer.expects("get_array_of_#{@inferred_type}".to_sym).with(0, @length).returns(result)
+        assert_equal result, @instance.dereference_pointer_array(@pointer, @type, @length)
+      end
+
+      should "call read_* on Util if pointer doesn't support it" do
+        result = mock("result")
+        @array_pointer.expects(:respond_to?).with("get_array_of_#{@inferred_type}".to_sym).returns(false)
+        @instance.expects("read_array_of_#{@inferred_type}".to_sym).with(@array_pointer, @type, @length).returns(result)
+        assert_equal result, @instance.dereference_pointer_array(@pointer, @type, @length)
+      end
+    end
+
+    context "custom pointer dereferencers" do
+      context "reading unicode string" do
+        setup do
+          @sub_ptr = mock("sub_ptr")
+          @sub_ptr.stubs(:null?).returns(false)
+
+          @ptr = mock("pointer")
+          @ptr.stubs(:get_pointer).returns(@sub_ptr)
+        end
+
+        should "return empty string for null pointer" do
+          @sub_ptr.expects(:null?).returns(true)
+          @instance.expects(:utf16_to_string).never
+          assert_equal "", @instance.read_unicode_string(@ptr)
+        end
+
+        should "call utf16_to_string on the dereferenced pointer" do
+          result = mock("result")
+          @ptr.expects(:get_pointer).with(0).returns(@sub_ptr)
+          @instance.expects(:utf16_to_string).with(@sub_ptr).returns(result)
+          assert_equal result, @instance.read_unicode_string(@ptr)
+        end
+      end
+
+      context "reading interfaces" do
+        setup do
+          @original_type = :foo
+          @interface_klass = mock("foo_class")
+
+          @sub_ptr = mock("sub_ptr")
+          @sub_ptr.stubs(:null?).returns(false)
+
+          @ptr = mock("pointer")
+          @ptr.stubs(:get_pointer).with(0).returns(@sub_ptr)
+        end
+
+        should "convert type to a const and return instance" do
+          @instance.expects(:interface_klass).with(@original_type).returns(@interface_klass)
+          @interface_klass.expects(:new).with(@klass, @instance.lib, @ptr.get_pointer(0)).returns(@instance)
+          assert_equal @instance, @instance.read_interface(@ptr, @original_type)
+        end
+
+        should "return nil if pointer is null" do
+          @sub_ptr.expects(:null?).returns(true)
+          @instance.expects(:interface_klass).never
+          assert_nil @instance.read_interface(@ptr, @original_type)
+        end
+      end
+
+      context "reading an enum" do
+        setup do
+          @enum_klass = mock("enum_class")
+          @enum_klass.stubs(:[])
+
+          @original_type = :foo
+          @value = 7
+
+          @ptr = mock("ptr")
+          @ptr.stubs(:get_uint).returns(@value)
+        end
+
+        should "convert type to class and get the value" do
+          result = mock("result")
+          @instance.expects(:interface_klass).with(@original_type).returns(@enum_klass)
+          @enum_klass.expects(:[]).with(@value).returns(result)
+          assert_equal result, @instance.read_enum(@ptr, @original_type)
+        end
+      end
+
+      context "reading an array of enums" do
+        setup do
+          @type = :foo
+          @length = 3
+
+          @pointers = []
+          @length.times do |i|
+            pointer = mock("pointer#{i}")
+            @pointers << pointer
+          end
+
+          @pointer = mock("pointer")
+          @pointer.stubs(:get_array_of_uint).returns(@pointers)
+
+          @interface_klass = mock("foo_class")
+
+          @instance.stubs(:read_struct).returns("foo")
+        end
+
+        should "grab the array of pointers, then convert each to a struct" do
+          deref_seq = sequence("deref_seq")
+          @instance.expects(:interface_klass).with(@type).returns(@interface_klass)
+          @pointer.expects(:get_array_of_uint).with(0, @length).returns(@pointers).in_sequence(deref_seq)
+          return_values = @pointers.collect do |pointer|
+            value = "struct_of_pointer: #{pointer}"
+            @interface_klass.expects(:[]).with(pointer).returns(value).in_sequence(deref_seq)
+            value
+          end
+
+          assert_equal return_values, @instance.read_array_of_enum(@pointer, @type, @length)
+        end
+      end
+
+      context "reading an array of interfaces" do
+        setup do
+          @type = :foo
+          @length = 3
+
+          @pointers = []
+          @length.times do |i|
+            pointer = mock("pointer#{i}")
+            @pointers << pointer
+          end
+
+          @pointer = mock("pointer")
+          @pointer.stubs(:get_array_of_pointer).returns(@pointers)
+
+          @interface_klass = mock("foo_class")
+
+          @instance.stubs(:read_struct).returns("foo")
+        end
+
+        should "grab the array of pointers, then convert each to a struct" do
+          deref_seq = sequence("deref_seq")
+          @instance.expects(:interface_klass).with(@type).returns(@interface_klass)
+          @pointer.expects(:get_array_of_pointer).with(0, @length).returns(@pointers).in_sequence(deref_seq)
+          return_values = @pointers.collect do |pointer|
+            value = "struct_of_pointer: #{pointer}"
+            @interface_klass.expects(:new).with(@klass, @instance.lib, pointer).returns(value).in_sequence(deref_seq)
+            value
+          end
+
+          assert_equal return_values, @instance.read_array_of_interface(@pointer, @type, @length)
+        end
+      end
+
+      context "reading an array of unicode strings" do
+        setup do
+          @type = :foo
+          @length = 3
+
+          @pointers = []
+          @length.times do |i|
+            pointer = mock("pointer#{i}")
+            pointer.stubs(:null?).returns(false)
+            @pointers << pointer
+          end
+
+          @pointer = mock("pointer")
+          @pointer.stubs(:get_array_of_pointer).returns(@pointers)
+
+          @instance.stubs(:read_struct).returns("foo")
+        end
+
+        should "grab the array of pointers, then convert each to a UTF8 string" do
+          deref_seq = sequence("deref_seq")
+          @pointer.expects(:get_array_of_pointer).with(0, @length).returns(@pointers).in_sequence(deref_seq)
+          return_values = @pointers.collect do |pointer|
+            value = "struct_of_pointer: #{pointer}"
+            @instance.expects(:utf16_to_string).with(pointer).returns(value).in_sequence(deref_seq)
+            value
+          end
+
+          assert_equal return_values, @instance.read_array_of_unicode_string(@pointer, @type, @length)
+        end
+
+        should "treat nil pointers as nil" do
+          deref_seq = sequence("deref_seq")
+          @pointer.expects(:get_array_of_pointer).with(0, @length).returns(@pointers).in_sequence(deref_seq)
+          return_values = @pointers.collect do |pointer|
+            pointer.expects(:null?).returns(true)
+            nil
+          end
+
+          assert_equal return_values, @instance.read_array_of_unicode_string(@pointer, @type, @length)
+        end
+      end
+    end
+  end
+end