gir_ffi 0.0.1

data/tasks/notes.rake

@@ -0,0 +1,134 @@
+# The following code is copied straight from Bones 2.5.1
+#
+
+begin
+  require 'facets/ansicode'
+  HAVE_COLOR = true
+rescue LoadError
+  HAVE_COLOR = false
+end
+
+module Bones
+
+# A helper class used to find and display any annotations in a collection of
+# project files.
+#
+class AnnotationExtractor
+
+  class Annotation < Struct.new(:line, :tag, :text)
+    # Returns a string representation of the annotation. If the
+    # <tt>:tag</tt> parameter is given as +true+, then the annotation tag
+    # will be included in the string.
+    #
+    def to_s( opts = {} )
+      s = "[%3d] " % line
+      s << "[#{tag}] " if opts[:tag]
+      s << text
+    end
+  end
+
+  # Enumerate all the annoations for the given _project_ and _tag_. This
+  # will search for all athe annotations and display them on standard
+  # output.
+  #
+  def self.enumerate( project, tag, id = nil, opts = {} )
+    extractor = new(project, tag, id)
+    extractor.display(extractor.find, opts)
+  end
+
+  attr_reader :tag, :project, :id
+
+  # Creates a new annotation extractor configured to use the _project_ open
+  # strcut and to search for the given _tag_ (which can be more than one tag
+  # via a regular expression 'or' operation -- i.e. THIS|THAT|OTHER)
+  #
+  def initialize( project, tag, id) 
+    @project = project
+    @tag = tag
+    @id = @id_rgxp = nil
+
+    unless id.nil? or id.empty?
+      @id = id
+      @id_rgxp = Regexp.new(Regexp.escape(id), Regexp::IGNORECASE)
+    end
+  end
+
+  # Iterate over all the files in the project and extract annotations from
+  # the those files. Returns the results as a hash for display.
+  #
+  def find
+    results = {}
+    rgxp = %r/(#{tag}):?\s*(.*?)(?:\s*(?:-?%>|\*+\/))?$/o
+
+    extensions = project.notes.extensions.dup
+    exclude = if project.notes.exclude.empty? then nil
+              else Regexp.new(project.notes.exclude.join('|')) end
+
+    manifest.each do |fn|
+      next if exclude && exclude =~ fn
+      next unless extensions.include? File.extname(fn)
+      results.update(extract_annotations_from(fn, rgxp))
+    end
+
+    results
+  end
+
+  # Extract any annotations from the given _file_ using the regular
+  # expression _pattern_ provided.
+  #
+  def extract_annotations_from( file, pattern )
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless m = pattern.match(line)
+      next list << Annotation.new(lineno, m[1], m[2]) unless id
+
+      text = m[2]
+      if text =~ @id_rgxp
+        text.gsub!(@id_rgxp) {|str| ANSICode.green(str)} if HAVE_COLOR
+        list << Annotation.new(lineno, m[1], text)
+      end
+      list
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  # Print the results of the annotation extraction to the screen. If the
+  # <tt>:tags</tt> option is set to +true+, then the annotation tag will be
+  # displayed.
+  #
+  def display( results, opts = {} )
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(opts)}"
+      end
+      puts
+    end
+  end
+
+end  # class AnnotationExtractor
+end  # module Bones
+
+desc "Enumerate all annotations"
+task :notes do |t|
+  id = if t.application.top_level_tasks.length > 1
+    t.application.top_level_tasks.slice!(1..-1).join(' ')
+  end
+  Bones::AnnotationExtractor.enumerate(
+      PROJ, PROJ.notes.tags.join('|'), id, :tag => true)
+end
+
+namespace :notes do
+  PROJ.notes.tags.each do |tag|
+    desc "Enumerate all #{tag} annotations"
+    task tag.downcase.to_sym do |t|
+      id = if t.application.top_level_tasks.length > 1
+        t.application.top_level_tasks.slice!(1..-1).join(' ')
+      end
+      Bones::AnnotationExtractor.enumerate(PROJ, tag, id)
+    end
+  end
+end
+
+# EOF

data/tasks/post_load.rake

@@ -0,0 +1,25 @@
+
+# This file does not define any rake tasks. It is used to load some project
+# settings if they are not defined by the user.
+
+PROJ.exclude << ["^#{Regexp.escape(PROJ.ignore_file)}$"]
+
+flatten_arrays = lambda do |this,os|
+    os.instance_variable_get(:@table).each do |key,val|
+      next if key == :dependencies \
+           or key == :development_dependencies
+      case val
+      when Array; val.flatten!
+      when OpenStruct; this.call(this,val)
+      end
+    end
+  end
+flatten_arrays.call(flatten_arrays,PROJ)
+
+PROJ.changes ||= paragraphs_of(PROJ.history_file, 0..1).join("\n\n")
+
+PROJ.description ||= paragraphs_of(PROJ.readme_file, 'description').join("\n\n")
+
+PROJ.summary ||= PROJ.description.split('.').first
+
+# EOF

data/tasks/setup.rb

@@ -0,0 +1,138 @@
+
+require 'rake'
+require 'rake/clean'
+require 'fileutils'
+require 'ostruct'
+require 'find'
+
+# TODO: Clean up bones' task set to remove unwanted parts.
+
+PROJ = OpenStruct.new(
+  # Project Defaults
+  :name => nil,
+  :summary => nil,
+  :description => nil,
+  :changes => nil,
+  :authors => nil,
+  :email => nil,
+  :url => "\000",
+  :version => ENV['VERSION'] || '0.0.0',
+  :exclude => %w(tmp$ bak$ ~$ CVS \.svn/ \.git/ ^pkg/),
+  :release_name => ENV['RELEASE'],
+
+  # System Defaults
+  :ruby_opts => %w(-w),
+  :libs => [],
+  :history_file => 'History.txt',
+  :readme_file => 'README.txt',
+  :ignore_file => '.bnsignore',
+
+  # File Annotations
+  :notes => OpenStruct.new(
+    :exclude => %w(^tasks/setup\.rb$),
+    :extensions => %w(.txt .rb .erb .rdoc) << '',
+    :tags => %w(FIXME OPTIMIZE TODO)
+  ),
+
+  # Test::Unit
+  :test => OpenStruct.new(
+    :files => FileList['test/**/*_test.rb'],
+    :file  => 'test/all.rb',
+    :opts  => []
+  )
+)
+
+# Load the other rake files in the tasks folder
+tasks_dir = File.expand_path(File.dirname(__FILE__))
+post_load_fn = File.join(tasks_dir, 'post_load.rake')
+rakefiles = Dir.glob(File.join(tasks_dir, '*.rake')).sort
+rakefiles.unshift(rakefiles.delete(post_load_fn)).compact!
+import(*rakefiles)
+
+# Setup the project libraries
+%w(lib ext).each {|dir| PROJ.libs << dir if test ?d, dir}
+
+%w(facets/ansicode).each do |lib|
+  begin
+    require lib
+    Object.instance_eval {const_set "HAVE_#{lib.tr('/','_').upcase}", true}
+  rescue LoadError
+    Object.instance_eval {const_set "HAVE_#{lib.tr('/','_').upcase}", false}
+  end
+end
+
+# Reads a file at +path+ and spits out an array of the +paragraphs+
+# specified.
+#
+#    changes = paragraphs_of('History.txt', 0..1).join("\n\n")
+#    summary, *description = paragraphs_of('README.txt', 3, 3..8)
+#
+def paragraphs_of( path, *paragraphs )
+  title = String === paragraphs.first ? paragraphs.shift : nil
+  ary = File.read(path).delete("\r").split(/\n\n+/)
+
+  result = if title
+    tmp, matching = [], false
+    rgxp = %r/^=+\s*#{Regexp.escape(title)}/i
+    paragraphs << (0..-1) if paragraphs.empty?
+
+    ary.each do |val|
+      if val =~ rgxp
+        break if matching
+        matching = true
+        rgxp = %r/^=+/i
+      elsif matching
+        tmp << val
+      end
+    end
+    tmp
+  else ary end
+
+  result.values_at(*paragraphs)
+end
+
+# Adds the given arguments to the include path if they are not already there
+#
+def ensure_in_path( *args )
+  args.each do |path|
+    path = File.expand_path(path)
+    $:.unshift(path) if test(?d, path) and not $:.include?(path)
+  end
+end
+
+# Scans the current working directory and creates a list of files that are
+# candidates to be in the manifest.
+#
+def manifest
+  files = []
+  exclude = PROJ.exclude.dup
+  comment = %r/^\s*#/
+ 
+  # process the ignore file and add the items there to the exclude list
+  if test(?f, PROJ.ignore_file)
+    ary = []
+    File.readlines(PROJ.ignore_file).each do |line|
+      next if line =~ comment
+      line.chomp!
+      line.strip!
+      next if line.nil? or line.empty?
+
+      glob = line =~ %r/\*\./ ? File.join('**', line) : line
+      Dir.glob(glob).each {|fn| ary << "^#{Regexp.escape(fn)}"}
+    end
+    exclude.concat ary
+  end
+
+  # generate a regular expression from the exclude list
+  exclude = Regexp.new(exclude.join('|'))
+
+  Find.find '.' do |path|
+    path.sub! %r/^(\.\/|\/)/o, ''
+    next unless test ?f, path
+    next if path =~ exclude
+    files << path
+  end
+  files.sort!
+end
+
+# EOF

data/tasks/test.rake

@@ -0,0 +1,22 @@
+
+if test(?e, PROJ.test.file) or not PROJ.test.files.to_a.empty?
+require 'rake/testtask'
+
+namespace :test do
+
+  Rake::TestTask.new(:run) do |t|
+    t.libs = PROJ.libs
+    t.test_files = if test(?f, PROJ.test.file) then [PROJ.test.file]
+                   else PROJ.test.files end
+    t.ruby_opts += PROJ.ruby_opts
+    t.ruby_opts += PROJ.test.opts
+  end
+
+end  # namespace :test
+
+desc 'Alias to test:run'
+task :test => 'test:run'
+
+end
+
+# EOF

data/test/arg_helper_test.rb

@@ -0,0 +1,112 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+require 'gir_ffi/arg_helper'
+
+class ArgHelperTest < Test::Unit::TestCase
+  context "The int_to_inoutptr method's return value" do
+    setup do
+      @result = GirFFI::ArgHelper.int_to_inoutptr 24
+    end
+
+    should "be a FFI::Pointer" do
+      assert_equal "FFI::Pointer", @result.class.to_s
+    end
+
+    should "hold a pointer to the correct input value" do
+      assert_equal 24, @result.read_int
+    end
+  end
+
+  context "The string_array_to_inoutptr method" do
+    context "when called with an array of strings" do
+      setup do
+	@result = GirFFI::ArgHelper.string_array_to_inoutptr ["foo", "bar", "baz"]
+      end
+
+      should "return a FFI::Pointer" do
+	assert_equal "FFI::Pointer", @result.class.to_s
+      end
+
+      should "return a pointer to an array of pointers to strings" do
+	ptr = @result.read_pointer
+	ary = ptr.read_array_of_pointer(3)
+	assert_equal ["foo", "bar", "baz"], ary.map {|p| p.read_string}
+      end
+    end
+    context "when called with nil" do
+      should "return nil" do
+	assert_nil GirFFI::ArgHelper.string_array_to_inoutptr nil
+      end
+    end
+  end
+
+  context "The outptr_to_int method" do
+    setup do
+      @ptr = GirFFI::AllocationHelper.safe_malloc FFI.type_size(:int)
+      @ptr.write_int 342
+    end
+
+    should "retrieve the correct integer value" do
+      assert_equal 342, GirFFI::ArgHelper.outptr_to_int(@ptr)
+    end
+  end
+
+  context "The outptr_to_string_array method" do
+    context "when called with a valid pointer to a string array" do
+      setup do
+	p = GirFFI::AllocationHelper.safe_malloc FFI.type_size(:pointer) * 2
+	p.write_array_of_pointer ["one", "two"].map {|str|
+	  len = str.bytesize
+	  GirFFI::AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
+	}
+	@ptr = GirFFI::AllocationHelper.safe_malloc FFI.type_size(:pointer)
+	@ptr.write_pointer p
+      end
+
+      should "return the string array" do
+	assert_equal ["one", "two"],
+	  GirFFI::ArgHelper.outptr_to_string_array(@ptr, 2)
+      end
+    end
+
+    context "when called with a pointer to a string array containing a null pointer" do
+      setup do
+	ptrs = ["one", "two"].map {|str|
+	  len = str.bytesize
+	  GirFFI::AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
+	}
+	ptrs << nil
+	p = GirFFI::AllocationHelper.safe_malloc FFI.type_size(:pointer) * 3
+	p.write_array_of_pointer ptrs
+	@ptr = GirFFI::AllocationHelper.safe_malloc FFI.type_size(:pointer)
+	@ptr.write_pointer p
+      end
+
+      should "return render the null pointer as nil" do
+	assert_equal ["one", "two", nil],
+	  GirFFI::ArgHelper.outptr_to_string_array(@ptr, 3)
+      end
+    end
+
+    context "when called with nil" do
+      should "return nil" do
+	assert_nil GirFFI::ArgHelper.outptr_to_string_array(nil, 0)
+      end
+    end
+  end
+
+  context "The object_to_inptr method" do
+    context "when called with an object implementing to_ptr" do
+      should "return the result of to_ptr" do
+	obj = Object.new
+	def obj.to_ptr; :test_value; end
+	assert_equal :test_value, GirFFI::ArgHelper.object_to_inptr(obj)
+      end
+    end
+
+    context "when called with nil" do
+      should "return nil" do
+	assert_equal nil, GirFFI::ArgHelper.object_to_inptr(nil)
+      end
+    end
+  end
+end

data/test/builder_test.rb

@@ -0,0 +1,328 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+require 'gir_ffi/builder'
+
+class BuilderTest < Test::Unit::TestCase
+  context "The GirFFI::Builder module" do
+    # TODO: Use gir's sample Everything library for testing instead.
+    context "building GObject::Object" do
+      setup do
+	GirFFI::Builder.build_class 'GObject', 'Object', 'NS1'
+      end
+
+      should "create a method_missing method for the class" do
+	ms = NS1::GObject::Object.instance_methods(false).map(&:to_sym)
+	assert_contains ms, :method_missing
+      end
+
+      should "create a Lib module in the parent namespace ready to attach functions from gobject-2.0" do
+	gir = GirFFI::IRepository.default
+	expected = gir.shared_library 'GObject'
+	assert_same_elements [*expected], NS1::GObject::Lib.ffi_libraries.map(&:name)
+      end
+
+      should "create an array CALLBACKS inside the GObject::Lib module" do
+	assert_equal [], NS1::GObject::Lib::CALLBACKS
+      end
+
+      should "not replace existing classes" do
+	oldclass = NS1::GObject::Object
+	GirFFI::Builder.build_class 'GObject', 'Object', 'NS1'
+	assert_equal oldclass, NS1::GObject::Object
+      end
+    end
+
+    context "building Gtk::Window" do
+      setup do
+	GirFFI::Builder.build_class 'Gtk', 'Window', 'NS3'
+      end
+
+      should "build Gtk namespace" do
+	assert NS3::Gtk.const_defined? :Lib
+	assert NS3::Gtk.respond_to? :method_missing
+      end
+
+      should "build parent classes also" do
+	assert NS3::Gtk.const_defined? :Widget
+	assert NS3::Gtk.const_defined? :Object
+	assert NS3.const_defined? :GObject
+	assert NS3::GObject.const_defined? :InitiallyUnowned
+	assert NS3::GObject.const_defined? :Object
+      end
+
+      should "set up inheritence chain" do
+	assert_equal [
+	  NS3::Gtk::Window,
+	  NS3::Gtk::Bin,
+	  NS3::Gtk::Container,
+	  NS3::Gtk::Widget,
+	  NS3::Gtk::Object,
+	  NS3::GObject::InitiallyUnowned,
+	  NS3::GObject::Object
+	], NS3::Gtk::Window.ancestors[0..6]
+      end
+
+      should "create a Gtk::Window#to_ptr method" do
+	assert_contains NS3::Gtk::Window.instance_methods.map(&:to_sym), :to_ptr
+      end
+
+      should "attach gtk_window_new to Gtk::Lib" do
+	assert NS3::Gtk::Lib.respond_to? :gtk_window_new
+      end
+
+      should "result in Gtk::Window.new to succeed" do
+	assert_nothing_raised {NS3::Gtk::Window.new(:toplevel)}
+      end
+    end
+
+    context "building Gtk" do
+      setup do
+	GirFFI::Builder.build_module 'Gtk', 'NS2'
+      end
+
+      should "create a Lib module ready to attach functions from gtk-x11-2.0" do
+	# The Gtk module has more than one library on my current machine.
+	gir = GirFFI::IRepository.default
+	expected = (gir.shared_library 'Gtk').split(',')
+	assert_same_elements expected, NS2::Gtk::Lib.ffi_libraries.map(&:name)
+      end
+
+      should "create an array CALLBACKS inside the Gtk::Lib module" do
+	assert_equal [], NS2::Gtk::Lib::CALLBACKS
+      end
+
+      should "not replace existing module" do
+	oldmodule = NS2::Gtk
+	GirFFI::Builder.build_module 'Gtk', 'NS2'
+	assert_equal oldmodule, NS2::Gtk
+      end
+
+      should "not replace existing Lib module" do
+	oldmodule = NS2::Gtk::Lib
+	GirFFI::Builder.build_module 'Gtk', 'NS2'
+	assert_equal oldmodule, NS2::Gtk::Lib
+      end
+    end
+
+    context "looking at Gtk.main" do
+      setup do
+	@go = get_function_introspection_data 'Gtk', 'main'
+      end
+      # TODO: function_introspection_data should not return introspection data if not a function.
+      should "have correct introspection data" do
+	gir = GirFFI::IRepository.default
+	gir.require "Gtk", nil
+	go2 = gir.find_by_name "Gtk", "main"
+	assert_equal go2, @go
+      end
+
+      should "build correct definition of Gtk.main" do
+	code = GirFFI::Builder.send :function_definition, @go, Lib
+
+	expected = "def main\nLib.gtk_main\nend"
+
+	assert_equal cws(expected), cws(code)
+      end
+
+      should "attach function to Whatever::Lib" do
+	mod = Module.new
+	mod.const_set :Lib, libmod = Module.new
+	libmod.module_eval do
+	  extend FFI::Library
+	  ffi_lib "gtk-x11-2.0"
+	end
+
+	GirFFI::Builder.send :attach_ffi_function, mod, libmod, @go, nil
+	assert_contains libmod.public_methods.map(&:to_sym), :gtk_main
+      end
+    end
+
+    context "looking at Gtk.init" do
+      setup do
+	GirFFI::Builder.build_module 'Gtk'
+	@go = get_function_introspection_data 'Gtk', 'init'
+      end
+
+      should "delegate definition to FunctionDefinitionBuilder" do
+	code = GirFFI::Builder.send :function_definition, @go, Lib
+	expected = GirFFI::FunctionDefinitionBuilder.new(@go, Lib).generate
+	assert_equal cws(expected), cws(code)
+      end
+
+      should "have :pointer, :pointer as types of the arguments for the attached function" do
+	# FIXME: Ideally, we attach the function and test that it requires
+	# the correct argument types.
+	assert_equal [:pointer, :pointer], GirFFI::Builder.send(:ffi_function_argument_types, Gtk, Gtk::Lib, @go, nil)
+      end
+
+      should "have :void as return type for the attached function" do
+	assert_equal :void, GirFFI::Builder.send(:ffi_function_return_type, Gtk, Gtk::Lib, @go, nil)
+      end
+    end
+
+    context "looking at Gtk::Widget#show" do
+      setup do
+	@go = get_method_introspection_data 'Gtk', 'Widget', 'show'
+      end
+
+      should "delegate definition to FunctionDefinitionBuilder" do
+	code = GirFFI::Builder.send :function_definition, @go, Lib
+	expected = GirFFI::FunctionDefinitionBuilder.new(@go, Lib).generate
+	assert_equal cws(expected), cws(code)
+      end
+
+      should "have :pointer as types of the arguments for the attached function" do
+	assert_equal [:pointer], GirFFI::Builder.send(:ffi_function_argument_types, Gtk, Gtk::Lib, @go, nil)
+      end
+
+    end
+
+    context "looking at GObject.signal_connect_data" do
+      setup do
+	GirFFI::Builder.build_module 'GObject', 'NS5'
+	@go = get_function_introspection_data 'GObject', 'signal_connect_data'
+      end
+
+      should "delegate definition to FunctionDefinitionBuilder" do
+	code = GirFFI::Builder.send :function_definition, @go, Lib
+	expected = GirFFI::FunctionDefinitionBuilder.new(@go, Lib).generate
+	assert_equal cws(expected), cws(code)
+      end
+
+      should "have the correct types of the arguments for the attached function" do
+	assert_equal [:pointer, :string, :Callback, :pointer, :ClosureNotify, NS5::GObject::ConnectFlags],
+	  GirFFI::Builder.send(:ffi_function_argument_types, NS5::GObject, NS5::GObject::Lib, @go, 'NS5')
+      end
+
+      should "define ffi callback types :Callback and :ClosureNotify" do
+	GirFFI::Builder.setup_function 'GObject', NS5::GObject::Lib, NS5::GObject, 'signal_connect_data'
+	cb = NS5::GObject::Lib.find_type :Callback
+	cn = NS5::GObject::Lib.find_type :ClosureNotify
+
+	assert_equal FFI.find_type(:void), cb.result_type
+	assert_equal FFI.find_type(:void), cn.result_type
+	assert_equal [], cb.param_types
+	assert_equal [FFI.find_type(:pointer), FFI.find_type(:pointer)], cn.param_types
+      end
+
+      should "define ffi enum type ConnectFlags" do
+	assert_equal({:after => 1, :swapped => 2}, NS5::GObject::ConnectFlags.to_h)
+      end
+    end
+
+    context "building Everything::TestStructA" do
+      setup do
+	GirFFI::Builder.build_class 'Everything', 'TestStructA'
+      end
+
+      should "set up the correct struct members" do
+	assert_equal [:some_int, :some_int8, :some_double, :some_enum],
+	  Everything::TestStructA::Struct.members
+      end
+
+      should "set up struct members with the correct offset" do
+	info = GirFFI::IRepository.default.find_by_name 'Everything', 'TestStructA'
+	assert_equal info.fields.map{|f| [f.name.to_sym, f.offset]},
+	  Everything::TestStructA::Struct.offsets
+      end
+
+      should "set up struct members with the correct types" do
+	tags = [:int, :int8, :double, Everything::TestEnum]
+	assert_equal tags.map {|t| FFI.find_type t},
+	  Everything::TestStructA::Struct.layout.fields.map(&:type)
+      end
+    end
+
+    context "building Everything::TestBoxed" do
+      setup do
+	GirFFI::Builder.build_class 'Everything', 'TestBoxed'
+      end
+
+      should "set up #_real_new as an alias to #new" do
+	assert Everything::TestBoxed.respond_to? "_real_new"
+      end
+
+      should "allow creation using #new" do
+	tb = Everything::TestBoxed.new
+	assert_instance_of Everything::TestBoxed, tb
+      end
+
+      should "allow creation using alternative constructors" do
+	tb = Everything::TestBoxed.new_alternative_constructor1 1
+	assert_instance_of Everything::TestBoxed, tb
+	assert_equal 1, tb[:some_int8]
+
+	tb = Everything::TestBoxed.new_alternative_constructor2 1, 2
+	assert_instance_of Everything::TestBoxed, tb
+	assert_equal 1 + 2, tb[:some_int8]
+
+	tb = Everything::TestBoxed.new_alternative_constructor3 "54"
+	assert_instance_of Everything::TestBoxed, tb
+	assert_equal 54, tb[:some_int8]
+      end
+
+      should "make the equals method work" do
+	tb = Everything::TestBoxed.new_alternative_constructor1 123
+	tb2 = Everything::TestBoxed.new_alternative_constructor2 120, 3
+	assert_equal true, tb.equals(tb2)
+      end
+
+      should "make the copy method work" do
+	tb = Everything::TestBoxed.new_alternative_constructor1 123
+	tb2 = tb.copy
+	assert_instance_of Everything::TestBoxed, tb2
+	assert_equal 123, tb2[:some_int8], "fields copied"
+	tb2[:some_int8] = 89
+	assert_equal 123, tb[:some_int8], "is a true copy"
+      end
+    end
+
+    context "building Everything::TestEnum" do
+      setup do
+	GirFFI::Builder.build_class 'Everything', 'TestEnum'
+      end
+      should "create an object of type FFI::Enum" do
+	assert_instance_of FFI::Enum, Everything::TestEnum
+      end
+    end
+
+    # TODO: Should not allow functions to be called as methods, etc.
+
+    context "looking at Everything's functions" do
+      setup do
+	GirFFI::Builder.build_module 'Everything'
+      end
+
+      should "correctly handle test_boolean" do
+	assert_equal false, Everything.test_boolean(false)
+	assert_equal true, Everything.test_boolean(true)
+      end
+
+      should "correctly handle test_callback_user_data" do
+	a = :foo
+	result = Everything.test_callback_user_data Proc.new {|u|
+	  a = u
+	  5
+	}, :bar
+	assert_equal :bar, a
+	assert_equal 5, result
+      end
+    end
+
+    context "building the Everything module" do
+      setup do
+	GirFFI::Builder.build_module 'Everything', 'NS4'
+      end
+
+      should "create a method_missing method for the module" do
+	ms = (NS4::Everything.public_methods - Module.public_methods).map(&:to_sym)
+	assert_contains ms, :method_missing
+      end
+
+      should "cause the TestObj class to be autocreated" do
+	assert !NS4::Everything.const_defined?(:TestObj)
+	assert_nothing_raised {NS4::Everything::TestObj}
+	assert NS4::Everything.const_defined? :TestObj
+      end
+    end
+  end
+end