gir_ffi 0.0.6 → 0.0.7

data/test/function_definition_builder_test.rb

@@ -1,19 +1,19 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 
 class FunctionDefinitionBuilderTest < Test::Unit::TestCase
-  context "The FunctionDefinition builder" do
+  context "The Builder::Function class" do
     should "build correct definition of Gtk.init" do
       go = get_function_introspection_data 'Gtk', 'init'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
+      fbuilder = GirFFI::Builder::Function.new go, Lib
       code = fbuilder.generate
 
       expected = "
 	def init argv
 	  argc = argv.length
-	  _v1 = GirFFI::ArgHelper.int_to_inoutptr argc
+	  _v1 = GirFFI::ArgHelper.gint32_to_inoutptr argc
 	  _v3 = GirFFI::ArgHelper.utf8_array_to_inoutptr argv
 	  ::Lib.gtk_init _v1, _v3
-	  _v2 = GirFFI::ArgHelper.outptr_to_int _v1
+	  _v2 = GirFFI::ArgHelper.outptr_to_gint32 _v1
 	  GirFFI::ArgHelper.cleanup_ptr _v1
 	  _v4 = GirFFI::ArgHelper.outptr_to_utf8_array _v3, _v2
 	  GirFFI::ArgHelper.cleanup_ptr_array_ptr _v3, _v2
@@ -26,7 +26,7 @@ class FunctionDefinitionBuilderTest < Test::Unit::TestCase
 
     should "build correct definition of Gtk::Widget.show" do
       go = get_method_introspection_data 'Gtk', 'Widget', 'show'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
+      fbuilder = GirFFI::Builder::Function.new go, Lib
       code = fbuilder.generate
 
       expected = "
@@ -38,95 +38,78 @@ class FunctionDefinitionBuilderTest < Test::Unit::TestCase
       assert_equal cws(expected), cws(code)
     end
 
-    should "build correct definition of GObject.signal_connect_data" do
-      go = get_function_introspection_data 'GObject', 'signal_connect_data'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
+    should "build correct definition of Regress.test_callback_destroy_notify" do
+      go = get_function_introspection_data 'Regress', 'test_callback_destroy_notify'
+      fbuilder = GirFFI::Builder::Function.new go, Lib
       code = fbuilder.generate
 
       expected =
-	"def signal_connect_data instance, detailed_signal, c_handler, data, destroy_data, connect_flags
-	  _v1 = GirFFI::ArgHelper.object_to_inptr instance
-	  _v2 = GirFFI::ArgHelper.utf8_to_inptr detailed_signal
-	  _v3 = GirFFI::ArgHelper.wrap_in_callback_args_mapper \"GObject\", \"Callback\", c_handler
+	"def test_callback_destroy_notify callback, user_data, notify
+	  _v1 = GirFFI::ArgHelper.wrap_in_callback_args_mapper \"Regress\", \"TestCallbackUserData\", callback
+	  ::Lib::CALLBACKS << _v1
+	  _v2 = GirFFI::ArgHelper.object_to_inptr user_data
+	  _v3 = GirFFI::ArgHelper.wrap_in_callback_args_mapper \"GLib\", \"DestroyNotify\", notify
 	  ::Lib::CALLBACKS << _v3
-	  _v4 = GirFFI::ArgHelper.object_to_inptr data
-	  _v5 = GirFFI::ArgHelper.wrap_in_callback_args_mapper \"GObject\", \"ClosureNotify\", destroy_data
-	  ::Lib::CALLBACKS << _v5
-	  _v6 = connect_flags
-	  _v7 = ::Lib.g_signal_connect_data _v1, _v2, _v3, _v4, _v5, _v6
-	  return _v7
+	  _v4 = ::Lib.regress_test_callback_destroy_notify _v1, _v2, _v3
+	  return _v4
 	end"
 
       assert_equal cws(expected), cws(code)
     end
 
-    should "build correct definition of Everything::TestObj#new_from_file" do
-      go = get_method_introspection_data 'Everything', 'TestObj', 'new_from_file'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
+    should "build correct definition of Regress::TestObj#new_from_file" do
+      go = get_method_introspection_data 'Regress', 'TestObj', 'new_from_file'
+      fbuilder = GirFFI::Builder::Function.new go, Lib
       code = fbuilder.generate
 
       expected =
 	"def new_from_file x
 	  _v1 = GirFFI::ArgHelper.utf8_to_inptr x
 	  _v4 = FFI::MemoryPointer.new(:pointer).write_pointer nil
-	  _v2 = ::Lib.test_obj_new_from_file _v1, _v4
+	  _v2 = ::Lib.regress_test_obj_new_from_file _v1, _v4
 	  GirFFI::ArgHelper.check_error(_v4)
-	  _v3 = ::Everything::TestObj.wrap(_v2)
+	  _v3 = ::Regress::TestObj.constructor_wrap(_v2)
 	  return _v3
 	end"
 
       assert_equal cws(expected), cws(code)
     end
 
-    should "build correct definition of Everything:test_array_int_null_in" do
-      go = get_function_introspection_data 'Everything', 'test_array_int_null_in'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
+    should "build correct definition of Regress:test_array_int_null_in" do
+      go = get_function_introspection_data 'Regress', 'test_array_int_null_in'
+      fbuilder = GirFFI::Builder::Function.new go, Lib
       code = fbuilder.generate
 
       expected =
 	"def test_array_int_null_in arr
-	  _v1 = GirFFI::ArgHelper.int_array_to_inptr arr
+	  _v1 = GirFFI::ArgHelper.gint32_array_to_inptr arr
 	  len = arr.nil? ? 0 : arr.length
 	  _v2 = len
-	  ::Lib.test_array_int_null_in _v1, _v2
+	  ::Lib.regress_test_array_int_null_in _v1, _v2
 	  GirFFI::ArgHelper.cleanup_ptr _v1
 	end"
 
       assert_equal cws(expected), cws(code)
     end
 
-    should "build correct definition of Everything:test_array_int_null_out" do
-      go = get_function_introspection_data 'Everything', 'test_array_int_null_out'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
+    should "build correct definition of Regress:test_array_int_null_out" do
+      go = get_function_introspection_data 'Regress', 'test_array_int_null_out'
+      fbuilder = GirFFI::Builder::Function.new go, Lib
       code = fbuilder.generate
 
       expected =
 	"def test_array_int_null_out
 	  _v1 = GirFFI::ArgHelper.pointer_outptr
-	  _v3 = GirFFI::ArgHelper.int_outptr
-	  ::Lib.test_array_int_null_out _v1, _v3
-	  _v4 = GirFFI::ArgHelper.outptr_to_int _v3
+	  _v3 = GirFFI::ArgHelper.gint32_outptr
+	  ::Lib.regress_test_array_int_null_out _v1, _v3
+	  _v4 = GirFFI::ArgHelper.outptr_to_gint32 _v3
 	  GirFFI::ArgHelper.cleanup_ptr _v3
-	  _v2 = GirFFI::ArgHelper.outptr_to_int_array _v1, _v4
+	  _v2 = GirFFI::ArgHelper.outptr_to_gint32_array _v1, _v4
 	  GirFFI::ArgHelper.cleanup_ptr_ptr _v1
 	  return _v2
 	end"
 
       assert_equal cws(expected), cws(code)
     end
-
-    should "build correct definition of Everything:test_utf8_nonconst_in" do
-      go = get_function_introspection_data 'Everything', 'test_utf8_nonconst_in'
-      fbuilder = GirFFI::FunctionDefinitionBuilder.new go, Lib
-      code = fbuilder.generate
-
-      expected =
-	"def test_utf8_nonconst_in in_
-	  _v1 = GirFFI::ArgHelper.utf8_to_inptr in_
-	  ::Lib.test_utf8_nonconst_in _v1
-	end"
-
-      assert_equal cws(expected), cws(code)
-    end
   end
 end

data/test/g_object_overrides_test.rb

@@ -4,43 +4,45 @@ class GObjectOverridesTest < Test::Unit::TestCase
   context "In the GObject module with overridden functions" do
     setup do
       GirFFI.setup :GObject
-      GirFFI.setup :Everything
+      GirFFI.setup :Regress
       GirFFI.setup :Gio
     end
 
-    context "the wrap_in_g_value function" do
-      should "wrap a boolean false" do
-	gv = GObject.wrap_in_g_value false
-	assert_instance_of GObject::Value, gv
-	assert_equal false, gv.get_boolean
+    context "the Value class" do
+      context "the wrap_ruby_value class method" do
+        should "wrap a boolean false" do
+          gv = GObject::Value.wrap_ruby_value false
+          assert_instance_of GObject::Value, gv
+          assert_equal false, gv.get_boolean
+        end
+
+        should "wrap a boolean true" do
+          gv = GObject::Value.wrap_ruby_value true
+          assert_instance_of GObject::Value, gv
+          assert_equal true, gv.get_boolean
+        end
       end
 
-      should "wrap a boolean true" do
-	gv = GObject.wrap_in_g_value true
-	assert_instance_of GObject::Value, gv
-	assert_equal true, gv.get_boolean
-      end
-    end
-
-    context "the unwrap_g_value function" do
-      should "unwrap a boolean false" do
-	gv = GObject.wrap_in_g_value false
-	result = GObject.unwrap_g_value gv
-	assert_equal false, result
-      end
-
-      should "unwrap a boolean true" do
-	gv = GObject.wrap_in_g_value true
-	result = GObject.unwrap_g_value gv
-	assert_equal true, result
+      context "the ruby_value method" do
+        should "unwrap a boolean false" do
+          gv = GObject::Value.wrap_ruby_value false
+          result = gv.ruby_value
+          assert_equal false, result
+        end
+
+        should "unwrap a boolean true" do
+          gv = GObject::Value.wrap_ruby_value true
+          result = gv.ruby_value
+          assert_equal true, result
+        end
       end
     end
 
     context "the signal_emit function" do
       should "emit a signal" do
 	a = 1
-	o = Everything::TestSubObj.new
-	GObject.signal_connect_data o, "test", Proc.new { a = 2 }, nil, nil, 0
+	o = Regress::TestSubObj.new
+	::GObject::Lib.g_signal_connect_data o, "test", Proc.new { a = 2 }, nil, nil, 0
 	GObject.signal_emit o, "test"
 	assert_equal 2, a
       end
@@ -50,14 +52,14 @@ class GObjectOverridesTest < Test::Unit::TestCase
 
 	argtypes = [:pointer, :pointer, :pointer, :pointer]
 	callback = FFI::Function.new(:bool, argtypes) { |a,b,c,d| true }
-	GObject.signal_connect_data s, "incoming", callback, nil, nil, 0
+	::GObject::Lib.g_signal_connect_data s, "incoming", callback, nil, nil, 0
 	rv = GObject.signal_emit s, "incoming"
 	assert_equal true, rv.get_boolean
       end
 
       should "pass in extra arguments" do
-	o = Everything::TestSubObj.new
-	sb = Everything::TestSimpleBoxedA.new
+	o = Regress::TestSubObj.new
+	sb = Regress::TestSimpleBoxedA.new
 	sb[:some_int8] = 31
 	sb[:some_double] = 2.42
 	sb[:some_enum] = :value2
@@ -67,10 +69,10 @@ class GObjectOverridesTest < Test::Unit::TestCase
 	callback = FFI::Function.new(:void, argtypes) do |a,b,c|
 	  b2 = b
 	end
-	GObject.signal_connect_data o, "test-with-static-scope-arg", callback, nil, nil, 0
+	::GObject::Lib.g_signal_connect_data o, "test-with-static-scope-arg", callback, nil, nil, 0
 	GObject.signal_emit o, "test-with-static-scope-arg", sb
 
-	sb2 = Everything::TestSimpleBoxedA.wrap b2
+	sb2 = Regress::TestSimpleBoxedA.wrap b2
 	assert sb.equals(sb2)
       end
     end
@@ -78,7 +80,7 @@ class GObjectOverridesTest < Test::Unit::TestCase
     context "the signal_connect function" do
       should "install a signal handler" do
 	a = 1
-	o = Everything::TestSubObj.new
+	o = Regress::TestSubObj.new
 	GObject.signal_connect(o, "test") { a = 2 }
 	GObject.signal_emit o, "test"
 	assert_equal 2, a
@@ -86,23 +88,23 @@ class GObjectOverridesTest < Test::Unit::TestCase
 
       should "pass user data to handler" do
 	a = 1
-	o = Everything::TestSubObj.new
+	o = Regress::TestSubObj.new
 	GObject.signal_connect(o, "test", 2) { |i, d| a = d }
 	GObject.signal_emit o, "test"
 	assert_equal 2, a
       end
 
       should "pass object to handler" do
-	o = Everything::TestSubObj.new
+	o = Regress::TestSubObj.new
 	o2 = nil
 	GObject.signal_connect(o, "test") { |i, d| o2 = i }
 	GObject.signal_emit o, "test"
-	assert_instance_of Everything::TestSubObj, o2
+	assert_instance_of Regress::TestSubObj, o2
 	assert_equal o.to_ptr, o2.to_ptr
       end
 
       should "not allow connecting an invalid signal" do
-	o = Everything::TestSubObj.new
+	o = Regress::TestSubObj.new
 	assert_raises RuntimeError do
 	  GObject.signal_connect(o, "not-really-a-signal") {}
 	end
@@ -116,7 +118,7 @@ class GObjectOverridesTest < Test::Unit::TestCase
       end
 
       should "require a block" do
-	o = Everything::TestSubObj.new
+	o = Regress::TestSubObj.new
 	assert_raises ArgumentError do
 	  GObject.signal_connect o, "test"
 	end
@@ -127,8 +129,8 @@ class GObjectOverridesTest < Test::Unit::TestCase
 	  @a = nil
 	  @b = 2
 
-	  o = Everything::TestSubObj.new
-	  sb = Everything::TestSimpleBoxedA.new
+	  o = Regress::TestSubObj.new
+	  sb = Regress::TestSimpleBoxedA.new
 	  sb[:some_int] = 23
 
 	  GObject.signal_connect(o, "test-with-static-scope-arg", 2) { |i, object, d|
@@ -143,7 +145,7 @@ class GObjectOverridesTest < Test::Unit::TestCase
 	end
 
 	should "pass on the extra arguments" do
-	  assert_instance_of Everything::TestSimpleBoxedA, @b
+	  assert_instance_of Regress::TestSimpleBoxedA, @b
 	  assert_equal 23, @b[:some_int]
 	end
       end
@@ -154,8 +156,8 @@ class GObjectOverridesTest < Test::Unit::TestCase
       context "#signal_arguments_to_gvalue_array" do
 	context "the result of wrapping test-with-static-scope-arg" do
 	  setup do
-	    o = Everything::TestSubObj.new
-	    b = Everything::TestSimpleBoxedA.new
+	    o = Regress::TestSubObj.new
+	    b = Regress::TestSimpleBoxedA.new
 
 	    @gva =
 	      GirFFI::Overrides::GObject::Helper.signal_arguments_to_gvalue_array(
@@ -171,11 +173,11 @@ class GObjectOverridesTest < Test::Unit::TestCase
 	  end
 
 	  should "have a first value with GType for TestSubObj" do
-	    assert_equal Everything::TestSubObj.get_gtype, (@gva.get_nth 0)[:g_type]
+	    assert_equal Regress::TestSubObj.get_gtype, (@gva.get_nth 0)[:g_type]
 	  end
 
 	  should "have a second value with GType for TestSimpleBoxedA" do
-	    assert_equal Everything::TestSimpleBoxedA.get_gtype, (@gva.get_nth 1)[:g_type]
+	    assert_equal Regress::TestSimpleBoxedA.get_gtype, (@gva.get_nth 1)[:g_type]
 	  end
 	end
       end
@@ -184,8 +186,8 @@ class GObjectOverridesTest < Test::Unit::TestCase
 	context "the result of casting pointers for the test-with-static-scope-arg signal" do
 	  setup do
 	    sig_name = "test-with-static-scope-arg"
-	    o = Everything::TestSubObj.new
-	    b = Everything::TestSimpleBoxedA.new
+	    o = Regress::TestSubObj.new
+	    b = Regress::TestSimpleBoxedA.new
 	    ud = GirFFI::ArgHelper.object_to_inptr "Hello!"
 	    sig = o.class.gir_ffi_builder.find_signal sig_name
 
@@ -200,13 +202,13 @@ class GObjectOverridesTest < Test::Unit::TestCase
 
 	  context "its first value" do
 	    should "be a TestSubObj" do
-	      assert_instance_of Everything::TestSubObj, @gva[0]
+	      assert_instance_of Regress::TestSubObj, @gva[0]
 	    end
 	  end
 
 	  context "its second value" do
 	    should "be a TestSimpleBoxedA" do
-	      assert_instance_of Everything::TestSimpleBoxedA, @gva[1]
+	      assert_instance_of Regress::TestSimpleBoxedA, @gva[1]
 	    end
 	  end
 
@@ -218,6 +220,59 @@ class GObjectOverridesTest < Test::Unit::TestCase
 	end
       end
     end
+
+    context "The RubyClosure class" do
+      should "have a constructor with a block argument" do
+        assert_raises ArgumentError do
+          GObject::RubyClosure.new
+        end
+      end
+
+      should "be a kind of Closure" do
+        c = GObject::RubyClosure.new {}
+        assert_kind_of GObject::Closure, c
+      end
+
+      should "be able to retrieve its block from its struct" do
+        a = 0
+        c = GObject::RubyClosure.new { a = 2 }
+        c2 = GObject::RubyClosure.wrap(c.to_ptr)
+        c2.block.call
+        assert_equal 2, a
+      end
+
+      context "its #marshaller singleton method" do
+        should "invoke its closure argument's block" do
+          a = 0
+          c = GObject::RubyClosure.new { a = 2 }
+          GObject::RubyClosure.marshaller(c, nil, 0, nil, nil, nil)
+          assert_equal 2, a
+        end
+
+        should "work when its closure argument is a GObject::Closure" do
+          a = 0
+          c = GObject::RubyClosure.new { a = 2 }
+          c2 = GObject::Closure.wrap(c.to_ptr)
+          GObject::RubyClosure.marshaller(c2, nil, 0, nil, nil, nil)
+          assert_equal 2, a
+        end
+
+        should "store the closure's return value in the proper gvalue" do
+          c = GObject::RubyClosure.new { 2 }
+          gv = GObject::Value.new
+          GObject::RubyClosure.marshaller(c, gv, 0, nil, nil, nil)
+          assert_equal 2, gv.ruby_value
+        end
+      end
+
+      should "have GObject::Closure#invoke call its block" do
+        a = 0
+        c = GObject::RubyClosure.new { a = 2 }
+        c2 = GObject::Closure.wrap(c.to_ptr)
+        c2.invoke nil, nil, nil
+        assert_equal 2, a
+      end
+    end
   end
 end