virtualbox 0.5.4 → 0.6.0

data/test/virtualbox/audio_adapter_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AudioAdapterTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::AudioAdapter
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+
+        @audio_adapter = mock("audio_adapter")
+        @interface.stubs(:audio_adapter).returns(@audio_adapter)
+      end
+
+      should "call new for the interface" do
+        @klass.expects(:new).with(nil, @audio_adapter).once.returns(@instance)
+        assert_equal @instance, @klass.populate_relationship(nil, @interface)
+      end
+    end
+
+    context "saving relationship" do
+      should "call save with the interface on the instance" do
+        instance = mock("instance")
+        instance.expects(:save).once
+
+        @klass.save_relationship(nil, instance)
+      end
+    end
+  end
+
+  context "initializing" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      setup do
+        @audio_adapter = mock("audio_adapter")
+        @session = mock("session")
+        @machine = mock("machine")
+        @machine.stubs(:audio_adapter).returns(@audio_adapter)
+        @session.stubs(:machine).returns(@machine)
+        @parent.stubs(:with_open_session).yields(@session)
+      end
+
+      should "save the interface settings with the new bios settings" do
+        save_seq = sequence("save_seq")
+        @instance.expects(:save_changed_interface_attributes).with(@audio_adapter).once.in_sequence(save_seq)
+        @instance.save
+      end
+    end
+  end
+end

data/test/virtualbox/bios_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class BIOSTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::BIOS
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+
+        @bios_settings = mock("bios_settings")
+        @interface.stubs(:bios_settings).returns(@bios_settings)
+      end
+
+      should "call new for the interface" do
+        @klass.expects(:new).with(nil, @bios_settings).once.returns(@instance)
+        assert_equal @instance, @klass.populate_relationship(nil, @interface)
+      end
+    end
+
+    context "saving relationship" do
+      should "call save with the interface on the instance" do
+        instance = mock("instance")
+        instance.expects(:save).once
+
+        @klass.save_relationship(nil, instance)
+      end
+    end
+  end
+
+  context "initializing" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      setup do
+        @bios_settings = mock("bios_settings")
+        @session = mock("session")
+        @machine = mock("machine")
+        @machine.stubs(:bios_settings).returns(@bios_settings)
+        @session.stubs(:machine).returns(@machine)
+        @parent.stubs(:with_open_session).yields(@session)
+      end
+
+      should "save the interface settings with the new bios settings" do
+        save_seq = sequence("save_seq")
+        @instance.expects(:save_changed_interface_attributes).with(@bios_settings).once.in_sequence(save_seq)
+        @instance.save
+      end
+    end
+  end
+end

data/test/virtualbox/com/abstract_enum_test.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class COMAbstractEnumTest < Test::Unit::TestCase
+  context "setting up the map" do
+    setup do
+      @enum = VirtualBox::COM::AbstractEnum
+      @enum.reset!
+    end
+
+    should "set the map up and be able to access it" do
+      @enum.map([:a, :b, :c])
+      assert_equal :a, @enum[0]
+      assert_equal :b, @enum[1]
+      assert_equal :c, @enum[2]
+    end
+
+    should "do the reverse mapping of value to index" do
+      @enum.map([:a, :b, :c])
+      assert_equal 1, @enum.index(:b)
+    end
+
+    should "reset the map if another is given" do
+      @enum.map([:a])
+      @enum.map([:b])
+      assert_equal :b, @enum[0]
+    end
+
+    should "allow iterating over the enum" do
+      array = [:a, :b, :c]
+      other_array = []
+      @enum.map(array)
+      @enum.each do |item|
+        other_array << item
+      end
+
+      assert_equal array, other_array
+    end
+
+    should "include enumerable methods" do
+      array = [:a, :b, :c]
+      @enum.map(array)
+
+      @enum.each_with_index do |object, index|
+        assert_equal array[index], object
+      end
+    end
+  end
+end

data/test/virtualbox/com/abstract_implementer_test.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class AbstractImplementerTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::AbstractImplementer
+    @interface = mock("interface")
+  end
+
+  context "initialization" do
+    should "make the interface accessible" do
+      instance = @klass.new(@interface)
+      assert_equal @interface, instance.interface
+    end
+  end
+
+  context "base methods" do
+    setup do
+      @instance = @klass.new(@interface)
+    end
+
+    should "implement the read_property function" do
+      assert_nothing_raised {
+        @instance.read_property(:foo, :bar)
+      }
+    end
+
+    should "implement the write_property function" do
+      assert_nothing_raised {
+        @instance.write_property(:foo, :bar, :opts)
+      }
+    end
+
+    should "implement the call_function function" do
+      assert_nothing_raised {
+        @instance.call_function(:foo, [], :opts)
+      }
+    end
+  end
+end

data/test/virtualbox/com/abstract_interface_test.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class AbstractInterfaceTest < Test::Unit::TestCase
+  class EmptyAITest < VirtualBox::COM::AbstractInterface
+  end
+
+  class BasicAITest < EmptyAITest
+    function :foo, :int, []
+    function :foo2, :int, []
+    property :bar, :int
+    property :bar2, :int
+    property :bar3, :int
+  end
+
+  setup do
+    @impl_instance = mock("impl_instance")
+    @impl = mock("implementer")
+    @impl.stubs(:new).returns(@impl_instance)
+  end
+
+  context "class methods" do
+    context "without any members defined" do
+      setup do
+        @klass = EmptyAITest
+        @klass.members.clear
+
+        @klass.stubs(:define_method)
+      end
+
+      should "put defined functions in the members hash" do
+        assert_nil @klass.member(:foo)
+        @klass.function(:foo, :int, :bar)
+        assert @klass.member(:foo)
+      end
+
+      should "define an method for functions" do
+        @klass.expects(:define_method).with(:foo)
+        @klass.function(:foo, :int, :bar)
+      end
+
+      should "put defined properties in the members hash" do
+        assert_nil @klass.member(:foo)
+        @klass.property(:foo, :bar)
+        assert @klass.member(:foo)
+      end
+
+      should "create methods for reading and writing properties" do
+        @klass.expects(:define_method).with(:foo).once
+        @klass.expects(:define_method).with(:foo=).once
+        @klass.property(:foo, :bar)
+      end
+
+      should "not creating writing method for property if its readonly" do
+        @klass.expects(:define_method).with(:foo=).never
+        @klass.property(:foo, :bar, :readonly => true)
+      end
+    end
+
+    context "with members defined" do
+      setup do
+        @klass = BasicAITest
+      end
+
+      should "return the properties in order" do
+        properties = @klass.properties
+        properties.collect! { |prop| prop[0] }
+
+        assert_equal [:bar, :bar2, :bar3], properties
+      end
+
+      should "return the functions in order" do
+        funcs = @klass.functions
+        funcs.collect! { |func| func[0] }
+
+        assert_equal [:foo, :foo2], funcs
+      end
+    end
+  end
+
+  context "initialization" do
+    should "instantiate the implementer" do
+      @impl.expects(:new).with() do |interface, extra|
+        assert interface.is_a?(VirtualBox::COM::AbstractInterface)
+        assert_equal :foo, extra
+        true
+      end
+
+      BasicAITest.new(@impl, :foo)
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @interface = BasicAITest.new(@impl)
+    end
+
+    context "checking for property existence" do
+      should "return true for existing properties" do
+        assert @interface.has_property?(:bar)
+      end
+
+      should "return false non-existent properties and methods" do
+        assert !@interface.has_property?(:foo)
+      end
+    end
+
+    context "checking for function existence" do
+      should "return true for existing functions" do
+        assert @interface.has_function?(:foo)
+      end
+
+      should "return false non-existent function and properties" do
+        assert !@interface.has_function?(:bar)
+      end
+    end
+
+    context "reading a property" do
+      should "call read property on the implementer and return result" do
+        result = mock("result")
+        @impl_instance.expects(:read_property).with(:bar, anything).returns(result)
+        assert_equal result, @interface.bar
+      end
+    end
+
+    context "calling a function" do
+      should "call the call function method on the implementer and return result" do
+        result = mock("result")
+        @impl_instance.expects(:call_function).with(:foo, [1, 2, 3], anything).returns(result)
+        assert_equal result, @interface.foo(1, 2, 3)
+      end
+    end
+
+    context "inspecting" do
+      should "be just the class name" do
+        assert_equal "#<AbstractInterfaceTest::BasicAITest>", @interface.inspect
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class COMFFIInterfaceTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::COM::FFI::Interface
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "specifying a com interface" do
+    setup do
+      @com_interface = mock("com_interface")
+      VirtualBox::COM::Interface.stubs(:const_get).returns(@com_interface)
+      @klass.stubs(:define_vtbl_parent_for_interface)
+      @klass.stubs(:define_vtbl_for_interface)
+    end
+
+    should "get the interface with respect to the COM interfaces" do
+      VirtualBox::COM::Interface.expects(:const_get).with(@interface).returns(@com_interface)
+      @klass.com_interface(@interface, @parent)
+    end
+
+    should "define the vtbl parent and vtbl" do
+      @klass.expects(:define_vtbl_parent_for_interface).with(@com_interface)
+      @klass.expects(:define_vtbl_for_interface).with(@com_interface, @parent)
+      @klass.com_interface(@interface, @parent)
+    end
+  end
+
+  context "defining the vtbl parent class" do
+    setup do
+      @klass.layout_args.clear
+    end
+
+    should "create a basic struct with a pointer" do
+      @klass.expects(:const_set).with() do |name, klass|
+        assert_equal "VtblParent", name
+        assert_equal FFI::Struct, klass.superclass
+
+        true
+      end
+
+      @klass.define_vtbl_parent_for_interface(@interface)
+    end
+  end
+
+  context "defining the vtbl class" do
+    setup do
+      @klass.layout_args.clear
+
+      @klass.stubs(:define_interface_parent)
+      @klass.stubs(:define_interface_functions)
+      @klass.stubs(:define_interface_properties)
+    end
+
+    should "define the properties then functions" do
+      layout_mock = mock("layout")
+      layout_mock.stubs(:layout)
+      @klass.stubs(:const_set).returns(layout_mock)
+
+      def_seq = sequence("define_seq")
+      @klass.expects(:define_interface_parent).once.in_sequence(def_seq)
+      @klass.expects(:define_interface_properties).once.in_sequence(def_seq)
+      @klass.expects(:define_interface_functions).once.in_sequence(def_seq)
+      @klass.define_vtbl_for_interface(@interface)
+    end
+
+    should "define the constant with the proper class" do
+      layout_args = [[:foo], :bar]
+      layout_args.stubs(:clear) # Don't let the method overwrite them
+
+      klass = mock("klass")
+      klass.expects(:layout).with(*layout_args.flatten).once
+      Class.expects(:new).with(::FFI::Struct).returns(klass)
+      @klass.stubs(:layout_args).returns(layout_args)
+
+      @klass.expects(:const_set).with() do |name, set_klass|
+        assert_equal "Vtbl", name
+        assert_equal klass, set_klass
+
+        true
+      end.returns(klass)
+
+      @klass.define_vtbl_for_interface(@interface)
+    end
+  end
+
+  context "defining the interface parent" do
+    should "do nothing if nil is given" do
+      @klass.layout_args.expects(:<<).never
+      assert_nothing_raised { @klass.define_interface_parent(nil) }
+    end
+
+    should "get the class in the context of the FFI namespace" do
+      name = :foo
+      klass = mock("klass")
+      Object.expects(:module_eval).with("::VirtualBox::COM::FFI::#{name}::Vtbl").returns(klass)
+      @klass.layout_args.expects(:<<).with([:superklass, klass])
+      @klass.define_interface_parent(name)
+    end
+  end
+
+  context "defining all interface functions" do
+    setup do
+      @functions = []
+      @interface.stubs(:functions).returns(@functions)
+    end
+
+    def add_function(name, type, spec, opts={})
+      @functions << [name, {
+        :value_type => type,
+        :spec => spec,
+        :opts => opts
+      }]
+    end
+
+    should "define a function for the function" do
+      name = :foo
+      type = :bar
+      spec = [:baz]
+      add_function(name, type, spec)
+
+      @klass.expects(:define_interface_function).with(name, type, spec).once
+      @klass.define_interface_functions(@interface)
+    end
+
+    should "define functions in order" do
+      add_function(:foo, :bar, [:baz])
+      add_function(:bar, :baz, [:foo])
+
+      def_seq = sequence('define_seq')
+      @functions.each do |name, opts|
+        type = opts[:value_type]
+        spec = opts[:spec]
+        @klass.expects(:define_interface_function).with(name, type, spec).in_sequence(def_seq)
+      end
+
+      @klass.define_interface_functions(@interface)
+    end
+  end
+
+  context "defining a single interface function" do
+    setup do
+      @properties = []
+      @interface.stubs(:properties).returns(@properties)
+    end
+
+    def add_property(name, type, opts={})
+      @properties << [name, {
+        :value_type => type,
+        :opts => opts
+      }]
+    end
+
+    should "define a getter and setter for properties" do
+      name = :foo
+      type = :int
+      add_property(name, type)
+
+      @klass.expects(:define_interface_function).with("get_#{name}".to_sym, type)
+      @klass.expects(:define_interface_function).with("set_#{name}".to_sym, nil, [type])
+      @klass.define_interface_properties(@interface)
+    end
+
+    should "not define a setter for readonly properties" do
+      name = :foo
+      type = :int
+      add_property(name, type, :readonly => true)
+
+      @klass.expects(:define_interface_function).with("get_#{name}".to_sym, type)
+      @klass.expects(:define_interface_function).with("set_#{name}".to_sym, nil, [type]).never
+      @klass.define_interface_properties(@interface)
+    end
+
+    should "add properties in order" do
+      add_property(:foo, :int)
+      add_property(:bar, :uint)
+
+      def_seq = sequence('define_seq')
+      @properties.each do |name, opts|
+        type = opts[:value_type]
+        @klass.expects(:define_interface_function).with("get_#{name}".to_sym, type).in_sequence(def_seq)
+        @klass.expects(:define_interface_function).with("set_#{name}".to_sym, nil, [type]).in_sequence(def_seq)
+      end
+
+      @klass.define_interface_properties(@interface)
+    end
+  end
+
+  context "defining a function" do
+    setup do
+      @klass.layout_args.clear
+
+      @name = :foo
+      @spec = [:unicode_string]
+      @ffi_spec = VirtualBox::COM::FFI::Util.spec_to_ffi(@spec)
+    end
+
+    should "append the return type to the spec" do
+      expected = VirtualBox::COM::FFI::Util.spec_to_ffi(@spec.dup.push([:out, :int]))
+
+      @klass.expects(:callback).with(@name, expected, VirtualBox::COM::FFI::NSRESULT_TYPE)
+      @klass.define_interface_function(@name, :int, @spec)
+    end
+
+    should "turn the spec into FFI parameters, and create the callback" do
+      @klass.expects(:callback).with(@name, @ffi_spec, VirtualBox::COM::FFI::NSRESULT_TYPE)
+      @klass.define_interface_function(@name, nil, @spec)
+    end
+
+    should "add to the layout args" do
+      @klass.layout_args.expects(:<<).with([@name, @name]).once
+      @klass.define_interface_function(@name, nil, @spec)
+    end
+  end
+
+  context "initializing" do
+    setup do
+      @pointer = mock("pointer")
+    end
+
+    should "initialize the vtbl structs" do
+      @klass.any_instance.expects(:initialize_vtbl).with(@pointer)
+      @klass.new(@pointer)
+    end
+  end
+
+  context "initializing vtbl" do
+    setup do
+      @pointer = mock("pointer")
+      @klass = VirtualBox::COM::FFI::VirtualBox
+    end
+
+    should "initialize the VtblParent then the Vtbl" do
+      vtbl_pointer = mock("vtbl_pointer")
+      vtbl_parent = mock("vtbl_parent")
+      vtbl_parent.stubs(:[]).with(:vtbl).returns(vtbl_pointer)
+      vtbl = mock("vtbl")
+
+      init_seq = sequence("init_seq")
+      @klass::VtblParent.expects(:new).with(@pointer).returns(vtbl_parent).in_sequence(init_seq)
+      @klass::Vtbl.expects(:new).with(vtbl_pointer).returns(vtbl).in_sequence(init_seq)
+
+      instance = @klass.new(@pointer)
+      assert_equal vtbl_parent, instance.vtbl_parent
+      assert_equal vtbl, instance.vtbl
+    end
+  end
+end