gir_ffi 0.15.3 → 0.15.4

data/test/gir_ffi/user_defined_property_info_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-require "gir_ffi/user_defined_property_info"
-
-describe GirFFI::UserDefinedPropertyInfo do
-  let(:pspec) do
-    GObject.param_spec_int("foo-bar", "foo bar",
-                           "Foo Bar",
-                           1, 3, 2,
-                           readable: true, writable: true)
-  end
-  let(:container) { Object.new }
-  let(:info) { GirFFI::UserDefinedPropertyInfo.new pspec, container, 24 }
-
-  describe "#param_spec" do
-    it "returns the passed in parameter specification" do
-      _(info.param_spec).must_equal pspec
-    end
-  end
-
-  describe "#name" do
-    it "returns the accessor name from the parameter specification" do
-      _(info.name).must_equal "foo_bar"
-    end
-  end
-
-  describe "#ffi_type" do
-    it "returns the ffi type corresponding to the type tag" do
-      _(info.ffi_type).must_equal :int
-    end
-  end
-
-  describe "#field_type.tag" do
-    it "returns the mapped type symbol" do
-      _(info.field_type.tag).must_equal :gint
-    end
-  end
-end

data/test/gir_ffi/variable_name_generator_test.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-require "gir_ffi/variable_name_generator"
-
-describe GirFFI::VariableNameGenerator do
-  describe "#new_var" do
-    it "generates a sequence of predictable variable names" do
-      gen = GirFFI::VariableNameGenerator.new
-
-      assert_equal "_v1", gen.new_var
-      assert_equal "_v2", gen.new_var
-      assert_equal "_v3", gen.new_var
-      assert_equal "_v4", gen.new_var
-    end
-  end
-end

data/test/gir_ffi/version_test.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe "GirFFI::VERSION" do
-  it "is set to a valid version number" do
-    _(GirFFI::VERSION).must_match(/\d+\.\d+\.\d+/)
-  end
-end

data/test/gir_ffi/zero_terminated_test.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::ZeroTerminated do
-  describe ".from" do
-    let(:result) { GirFFI::ZeroTerminated.from :int32, [1, 2, 3] }
-
-    it "converts the passed array into a zero-terminated c array" do
-      ptr = result.to_ptr
-      _(ptr.read_array_of_int32(4)).must_equal [1, 2, 3, 0]
-    end
-
-    it "returns a GirFFI::ZeroTerminated object" do
-      _(result).must_be_instance_of GirFFI::ZeroTerminated
-    end
-
-    it "works for Regress::TestEnum from numbers" do
-      GirFFI.setup :Regress
-      enum_arr = GirFFI::ZeroTerminated.from Regress::TestEnum, [1, -1, 48]
-      ptr = enum_arr.to_ptr
-      _(ptr.read_array_of_int32(4)).must_equal [1, -1, 48, 0]
-    end
-
-    it "works for Regress::TestEnum from symbols" do
-      GirFFI.setup :Regress
-      enum_arr = GirFFI::ZeroTerminated.from Regress::TestEnum, [:value2, :value3, :value4]
-      ptr = enum_arr.to_ptr
-      _(ptr.read_array_of_int32(4)).must_equal [1, -1, 48, 0]
-    end
-  end
-
-  describe ".wrap" do
-    it "wraps the given type and pointer" do
-      ptr = GirFFI::InPointer.from_array :int32, [1, 2, 3, 0]
-      zt = GirFFI::ZeroTerminated.wrap :foo, ptr
-      _(zt.element_type).must_equal :foo
-      _(zt.to_ptr).must_equal ptr
-    end
-  end
-
-  describe "#each" do
-    it "yields each element" do
-      zt = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
-      arr = []
-      zt.each do |int|
-        arr << int
-      end
-      _(arr).must_equal [1, 2, 3]
-    end
-
-    it "yields zero times for a ZeroTerminated wrapping a null pointer" do
-      zt = GirFFI::ZeroTerminated.wrap :int32, FFI::Pointer.new(0)
-      zt.each do |_str|
-        flunk
-      end
-    end
-
-    it "works for :int8" do
-      zt = GirFFI::ZeroTerminated.from :int8, [1, 2, 3]
-      arr = []
-      zt.each do |int|
-        arr << int
-      end
-      _(arr).must_equal [1, 2, 3]
-    end
-  end
-
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
-
-      _(zero_terminated == [1, 2, 3]).must_equal true
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
-
-      _(zero_terminated == [1, 2]).must_equal false
-    end
-
-    it "returns true when comparing to a zero-terminated array with the same elements" do
-      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
-      other = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
-
-      _(zero_terminated == other).must_equal true
-    end
-
-    it "returns false when comparing to a zero-terminated array with different elements" do
-      zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
-      other = GirFFI::ZeroTerminated.from :int32, [1, 2]
-
-      _(zero_terminated == other).must_equal false
-    end
-  end
-
-  it "includes Enumerable" do
-    _(GirFFI::ZeroTerminated).must_include Enumerable
-  end
-
-  describe "#to_a" do
-    it "works for Regress::TestEnum" do
-      GirFFI.setup :Regress
-      enum_arr = GirFFI::ZeroTerminated.from Regress::TestEnum, [1, 48, -1]
-      _(enum_arr.to_a).must_equal [:value2, :value4, :value3]
-    end
-  end
-end

data/test/gir_ffi_test_helper.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "introspection_test_helper"
-
-require "gir_ffi"
-
-# Global sequence provider. Needed to make unique class names.
-class Sequence
-  def self.next
-    @seq ||= 0
-    @seq += + 1
-  end
-end
-
-module GirFFITestExtensions
-  SAVED_MODULES = {}
-
-  def save_module(name)
-    return unless Object.const_defined? name
-
-    puts "Saving #{name} over existing" if SAVED_MODULES.key? name
-    SAVED_MODULES[name] = Object.const_get name
-    Object.send(:remove_const, name)
-  end
-
-  def restore_module(name)
-    Object.send(:remove_const, name) if Object.const_defined? name
-    return unless SAVED_MODULES.key? name
-
-    Object.const_set name, SAVED_MODULES[name]
-    SAVED_MODULES.delete name
-  end
-
-  def object_ref_count(ptr)
-    GObject::Object::Struct.new(ptr.to_ptr)[:ref_count]
-  end
-
-  def max_for_unsigned_type(type)
-    (1 << (FFI.type_size(type) * 8)) - 1
-  end
-
-  def max_for_type(type)
-    (1 << (FFI.type_size(type) * 8 - 1)) - 1
-  end
-
-  def min_for_type(type)
-    ~max_for_type(type)
-  end
-
-  def max_long
-    max_for_type :long
-  end
-
-  def min_long
-    min_for_type :long
-  end
-
-  def max_size_t
-    max_for_unsigned_type :size_t
-  end
-
-  def max_ssize_t
-    # FFI has no :ssize_t, but it's the same number of bits as :size_t
-    max_for_type :size_t
-  end
-
-  def min_ssize_t
-    min_for_type :size_t
-  end
-
-  def max_ushort
-    max_for_unsigned_type :ushort
-  end
-
-  def max_uint
-    max_for_unsigned_type :uint
-  end
-
-  def max_ulong
-    max_for_unsigned_type :ulong
-  end
-end
-
-Minitest::Test.include GirFFITestExtensions

data/test/integration/callback_exceptions_test.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-
-class CallbackTestException < RuntimeError; end
-
-describe "An exception in a callback" do
-  describe "for signals" do
-    let(:object) { Regress::TestSubObj.new }
-
-    before do
-      object.signal_connect "test" do
-        raise CallbackTestException, "Boom"
-      end
-    end
-
-    describe "when the signal is emitted synchronously" do
-      it "raises an error" do
-        _(proc { GObject.signal_emit object, "test" }).must_raise CallbackTestException
-      end
-    end
-
-    describe "when the signal is emitted during an event loop" do
-      it "causes loop run to be terminated with an exception" do
-        main_loop = GLib::MainLoop.new nil, false
-
-        GLib.timeout_add GLib::PRIORITY_DEFAULT, 1 do
-          GObject.signal_emit object, "test"
-          false
-        end
-        # Guard against runaway loop
-        GLib.timeout_add GLib::PRIORITY_DEFAULT, 500 do
-          main_loop.quit
-        end
-        _(proc { main_loop.run }).must_raise CallbackTestException
-      end
-    end
-  end
-
-  describe "for other callbacks" do
-    describe "when the callback occurs during an event loop" do
-      it "causes loop run to be terminated with an exception" do
-        main_loop = GLib::MainLoop.new nil, false
-
-        GLib.timeout_add GLib::PRIORITY_DEFAULT, 1 do
-          raise CallbackTestException, "Boom"
-        end
-        # Guard against runaway loop
-        GLib.timeout_add GLib::PRIORITY_DEFAULT, 500 do
-          main_loop.quit
-        end
-
-        _(proc { main_loop.run }).must_raise CallbackTestException
-      end
-    end
-  end
-end

data/test/integration/derived_classes_test.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-
-# Tests deriving Ruby classes from GObject classes.
-describe "For derived classes" do
-  describe "setting up methods when first called" do
-    before do
-      save_module :GIMarshallingTests
-      GirFFI.setup :GIMarshallingTests
-    end
-
-    describe "when an interface is mixed in" do
-      before do
-        @klass = Class.new GIMarshallingTests::OverridesObject
-        @klass.send :include, GIMarshallingTests::Interface
-      end
-
-      it "finds class methods in the superclass" do
-        @klass.returnv
-      end
-
-      it "finds instance methods in the superclass" do
-        obj = @klass.new
-        result = obj.method
-        _(result).must_equal 42
-      end
-    end
-
-    after do
-      restore_module :GIMarshallingTests
-    end
-  end
-
-  describe "the initializer" do
-    it "works if it calls super" do
-      klass = Class.new Regress::TestSubObj do
-        attr_reader :animal
-
-        def initialize(animal)
-          super()
-          @animal = animal
-        end
-      end
-
-      obj = klass.new "dog"
-      _(obj).must_be_instance_of klass
-      _(obj.to_ptr).wont_be_nil
-      _(obj.animal).must_equal "dog"
-    end
-  end
-end

data/test/integration/generated_everything_test.rb

@@ -1,453 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Everything
-
-describe Everything do
-  it "has a working function #const_return_GType" do
-    _(Everything.const_return_GType).must_equal GObject::TYPE_OBJECT
-  end
-
-  it "has a working function #const_return_filename" do
-    _(Everything.const_return_filename).must_equal ""
-  end
-
-  it "has a working function #const_return_gboolean" do
-    _(Everything.const_return_gboolean).must_equal false
-  end
-
-  it "has a working function #const_return_gchar" do
-    _(Everything.const_return_gchar).must_equal 0
-  end
-
-  it "has a working function #const_return_gdouble" do
-    _(Everything.const_return_gdouble).must_equal 0
-  end
-
-  it "has a working function #const_return_gfloat" do
-    _(Everything.const_return_gfloat).must_equal 0
-  end
-
-  it "has a working function #const_return_gint" do
-    _(Everything.const_return_gint).must_equal 0
-  end
-
-  it "has a working function #const_return_gint16" do
-    _(Everything.const_return_gint16).must_equal 0
-  end
-
-  it "has a working function #const_return_gint32" do
-    _(Everything.const_return_gint32).must_equal 0
-  end
-
-  it "has a working function #const_return_gint64" do
-    _(Everything.const_return_gint64).must_equal 0
-  end
-
-  it "has a working function #const_return_gint8" do
-    _(Everything.const_return_gint8).must_equal 0
-  end
-
-  it "has a working function #const_return_gintptr" do
-    _(Everything.const_return_gintptr).must_equal 0
-  end
-
-  it "has a working function #const_return_glong" do
-    _(Everything.const_return_glong).must_equal 0
-  end
-
-  it "has a working function #const_return_gpointer" do
-    skip_below "1.47.1"
-    _(Everything.const_return_gpointer).must_be :null?
-  end
-
-  it "has a working function #const_return_gshort" do
-    _(Everything.const_return_gshort).must_equal 0
-  end
-
-  it "has a working function #const_return_gsize" do
-    _(Everything.const_return_gsize).must_equal 0
-  end
-
-  it "has a working function #const_return_gssize" do
-    _(Everything.const_return_gssize).must_equal 0
-  end
-
-  it "has a working function #const_return_guint" do
-    _(Everything.const_return_guint).must_equal 0
-  end
-
-  it "has a working function #const_return_guint16" do
-    _(Everything.const_return_guint16).must_equal 0
-  end
-
-  it "has a working function #const_return_guint32" do
-    _(Everything.const_return_guint32).must_equal 0
-  end
-
-  it "has a working function #const_return_guint64" do
-    _(Everything.const_return_guint64).must_equal 0
-  end
-
-  it "has a working function #const_return_guint8" do
-    _(Everything.const_return_guint8).must_equal 0
-  end
-
-  it "has a working function #const_return_guintptr" do
-    _(Everything.const_return_guintptr).must_equal 0
-  end
-
-  it "has a working function #const_return_gulong" do
-    _(Everything.const_return_gulong).must_equal 0
-  end
-
-  it "has a working function #const_return_gunichar" do
-    _(Everything.const_return_gunichar).must_equal 0
-  end
-
-  it "has a working function #const_return_gushort" do
-    _(Everything.const_return_gushort).must_equal 0
-  end
-
-  it "has a working function #const_return_utf8" do
-    _(Everything.const_return_utf8).must_equal ""
-  end
-
-  it "has a working function #nullfunc" do
-    _(Everything.nullfunc).must_be_nil
-  end
-
-  it "has a working function #one_outparam_GType" do
-    _(Everything.one_outparam_GType).must_equal 0
-  end
-
-  it "has a working function #one_outparam_filename" do
-    # NOTE: This function stores a null pointer in its output parameter.
-    _(Everything.one_outparam_filename).must_be_nil
-  end
-
-  it "has a working function #one_outparam_gboolean" do
-    _(Everything.one_outparam_gboolean).must_equal false
-  end
-
-  it "has a working function #one_outparam_gchar" do
-    skip "GIR gives the incorrect type: utf8 instead of gchar"
-    _(Everything.one_outparam_gchar).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gdouble" do
-    _(Everything.one_outparam_gdouble).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gfloat" do
-    _(Everything.one_outparam_gfloat).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gint" do
-    _(Everything.one_outparam_gint).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gint16" do
-    _(Everything.one_outparam_gint16).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gint32" do
-    _(Everything.one_outparam_gint32).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gint64" do
-    _(Everything.one_outparam_gint64).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gint8" do
-    _(Everything.one_outparam_gint8).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gintptr" do
-    _(Everything.one_outparam_gintptr).must_equal 0
-  end
-
-  it "has a working function #one_outparam_glong" do
-    _(Everything.one_outparam_glong).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gpointer" do
-    skip_below "1.47.1"
-    _(Everything.one_outparam_gpointer).must_be :null?
-  end
-
-  it "has a working function #one_outparam_gshort" do
-    _(Everything.one_outparam_gshort).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gsize" do
-    _(Everything.one_outparam_gsize).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gssize" do
-    _(Everything.one_outparam_gssize).must_equal 0
-  end
-
-  it "has a working function #one_outparam_guint" do
-    _(Everything.one_outparam_guint).must_equal 0
-  end
-
-  it "has a working function #one_outparam_guint16" do
-    _(Everything.one_outparam_guint16).must_equal 0
-  end
-
-  it "has a working function #one_outparam_guint32" do
-    _(Everything.one_outparam_guint32).must_equal 0
-  end
-
-  it "has a working function #one_outparam_guint64" do
-    _(Everything.one_outparam_guint64).must_equal 0
-  end
-
-  it "has a working function #one_outparam_guint8" do
-    _(Everything.one_outparam_guint8).must_equal 0
-  end
-
-  it "has a working function #one_outparam_guintptr" do
-    _(Everything.one_outparam_guintptr).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gulong" do
-    _(Everything.one_outparam_gulong).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gunichar" do
-    _(Everything.one_outparam_gunichar).must_equal 0
-  end
-
-  it "has a working function #one_outparam_gushort" do
-    _(Everything.one_outparam_gushort).must_equal 0
-  end
-
-  it "has a working function #one_outparam_utf8" do
-    # NOTE: This function stores a null pointer in its output parameter.
-    _(Everything.one_outparam_utf8).must_be_nil
-  end
-
-  it "has a working function #oneparam_GType" do
-    _(Everything.oneparam_GType(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_filename" do
-    _(Everything.oneparam_filename("")).must_be_nil
-  end
-
-  it "has a working function #oneparam_gboolean" do
-    _(Everything.oneparam_gboolean(false)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gchar" do
-    _(Everything.oneparam_gchar(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gdouble" do
-    _(Everything.oneparam_gdouble(0.0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gfloat" do
-    _(Everything.oneparam_gfloat(0.0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gint" do
-    _(Everything.oneparam_gint(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gint16" do
-    _(Everything.oneparam_gint16(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gint32" do
-    _(Everything.oneparam_gint32(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gint64" do
-    _(Everything.oneparam_gint64(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gint8" do
-    _(Everything.oneparam_gint8(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gintptr" do
-    _(Everything.oneparam_gintptr(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_glong" do
-    _(Everything.oneparam_glong(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gpointer" do
-    skip_below "1.47.1"
-    _(Everything.oneparam_gpointer(FFI::MemoryPointer.new(:int))).must_be_nil
-  end
-
-  it "has a working function #oneparam_gshort" do
-    _(Everything.oneparam_gshort(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gsize" do
-    _(Everything.oneparam_gsize(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gssize" do
-    _(Everything.oneparam_gssize(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_guint" do
-    _(Everything.oneparam_guint(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_guint16" do
-    _(Everything.oneparam_guint16(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_guint32" do
-    _(Everything.oneparam_guint32(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_guint64" do
-    _(Everything.oneparam_guint64(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_guint8" do
-    _(Everything.oneparam_guint8(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_guintptr" do
-    _(Everything.oneparam_guintptr(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gulong" do
-    _(Everything.oneparam_gulong(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gunichar" do
-    _(Everything.oneparam_gunichar(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_gushort" do
-    _(Everything.oneparam_gushort(0)).must_be_nil
-  end
-
-  it "has a working function #oneparam_utf8" do
-    _(Everything.oneparam_utf8("")).must_be_nil
-  end
-
-  it "has a working function #passthrough_one_GType" do
-    _(Everything.passthrough_one_GType(GObject::TYPE_OBJECT))
-      .must_equal GObject::TYPE_OBJECT
-  end
-
-  it "has a working function #passthrough_one_filename" do
-    _(Everything.passthrough_one_filename("foo")).must_equal "foo"
-  end
-
-  it "has a working function #passthrough_one_gboolean" do
-    _(Everything.passthrough_one_gboolean(true)).must_equal true
-  end
-
-  it "has a working function #passthrough_one_gchar" do
-    _(Everything.passthrough_one_gchar(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gdouble" do
-    _(Everything.passthrough_one_gdouble(23.42)).must_equal 23.42
-  end
-
-  it "has a working function #passthrough_one_gfloat" do
-    _(Everything.passthrough_one_gfloat(23.42)).must_be_close_to 23.42
-  end
-
-  it "has a working function #passthrough_one_gint" do
-    _(Everything.passthrough_one_gint(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gint16" do
-    _(Everything.passthrough_one_gint16(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gint32" do
-    _(Everything.passthrough_one_gint32(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gint64" do
-    _(Everything.passthrough_one_gint64(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gint8" do
-    _(Everything.passthrough_one_gint8(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gintptr" do
-    _(Everything.passthrough_one_gintptr(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_glong" do
-    _(Everything.passthrough_one_glong(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gpointer" do
-    skip_below "1.47.1"
-    ptr = FFI::MemoryPointer.new(:int)
-    result = Everything.passthrough_one_gpointer(ptr)
-    _(result).must_be :==, ptr
-  end
-
-  it "has a working function #passthrough_one_gshort" do
-    _(Everything.passthrough_one_gshort(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gsize" do
-    _(Everything.passthrough_one_gsize(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gssize" do
-    _(Everything.passthrough_one_gssize(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_guint" do
-    _(Everything.passthrough_one_guint(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_guint16" do
-    _(Everything.passthrough_one_guint16(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_guint32" do
-    _(Everything.passthrough_one_guint32(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_guint64" do
-    _(Everything.passthrough_one_guint64(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_guint8" do
-    _(Everything.passthrough_one_guint8(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_guintptr" do
-    _(Everything.passthrough_one_guintptr(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gulong" do
-    _(Everything.passthrough_one_gulong(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gunichar" do
-    _(Everything.passthrough_one_gunichar(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_gushort" do
-    _(Everything.passthrough_one_gushort(42)).must_equal 42
-  end
-
-  it "has a working function #passthrough_one_utf8" do
-    _(Everything.passthrough_one_utf8("42")).must_equal "42"
-  end
-end