gir_ffi 0.14.1 → 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.send :include, GirFFITestExtensions

data/test/integration/callback_exceptions_test.rb

@@ -1,63 +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 do
-          main_loop.run
-        end.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 do
-          main_loop.run
-        end.must_raise CallbackTestException
-      end
-    end
-  end
-end

data/test/integration/derived_classes_test.rb

@@ -1,53 +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,452 +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 unless get_introspection_data 'Everything', 'const_return_gpointer'
-    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 unless get_introspection_data 'Everything', 'one_outparam_gpointer'
-    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 unless get_introspection_data 'Everything', 'oneparam_gpointer'
-    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 unless get_introspection_data 'Everything', 'passthrough_one_gpointer'
-    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