RubyInline 3.1.0

data/inline.rb

@@ -0,0 +1,427 @@
+#!/usr/local/bin/ruby -w
+
+# Ruby Inline is a framework for writing ruby extensions in foreign
+# languages
+#
+# = SYNOPSIS
+#
+#   require 'inline'
+#   class MyClass
+#     inline do |builder|
+#       builder.include "<math.h>"
+#       builder.c %q{
+#         long factorial(int max) {
+#           int i=max, result=1;
+#           while (i >= 2) { result *= i--; }
+#           return result;
+#         }
+#       }
+#     end
+#   end
+# 
+# = DESCRIPTION
+# 
+# Inline allows you to write C/C++ code within your ruby code. It
+# automatically determines if the code in question has changed and
+# builds it only when necessary. The extensions are then automatically
+# loaded into the class/module that defines it.
+#
+# You can even write extra builders that will allow you to write
+# inlined code in any language. Use Inline::C as a template and look
+# at Module#inline for the required API.
+
+require "rbconfig"
+require "ftools"
+
+$TESTING = false unless defined? $TESTING
+
+# The Inline module is the top-level module used. It is responsible
+# for instantiating the builder for the right language used,
+# compilation/linking when needed, and loading the inlined code into
+# the current namespace.
+
+module Inline
+  VERSION = '3.1.0'
+
+  $stderr.puts "RubyInline v #{VERSION}" if $DEBUG
+
+  protected
+
+  def self.rootdir
+    unless defined? @@rootdir and test ?d, @@rootdir then
+      rootdir = ENV['INLINEDIR'] || ENV['HOME']
+      Dir.mkdir rootdir, 0700 unless test ?d, rootdir
+      Dir.assert_secure rootdir
+      @@rootdir = rootdir
+    end
+
+    @@rootdir
+  end
+
+  def self.directory
+    unless defined? @@directory and test ?d, @@directory then
+      directory = File.join(rootdir, ".ruby_inline")
+      unless File.directory? directory then
+	$stderr.puts "NOTE: creating #{directory} for RubyInline" if $DEBUG
+	Dir.mkdir directory, 0700
+      end
+      Dir.assert_secure directory
+      @@directory = directory
+    end
+    @@directory
+  end
+
+  # Inline::C is the default builder used and the only one provided by
+  # Inline. It can be used as a template to write builders for other
+  # languages. It understands type-conversions for the basic types and
+  # can be extended as needed.
+  
+  class C 
+
+    protected unless $TESTING
+
+    MAGIC_ARITY_THRESHOLD = 2
+    MAGIC_ARITY = -1
+
+    @@type_map = {
+      'char'          => [ 'NUM2CHR',  'CHR2FIX' ],
+      'char *'        => [ 'STR2CSTR', 'rb_str_new2' ],
+      'int'           => [ 'FIX2INT',  'INT2FIX' ],
+      'long'          => [ 'NUM2INT',  'INT2NUM' ],
+      'unsigned int'  => [ 'NUM2UINT', 'UINT2NUM' ],
+      'unsigned long' => [ 'NUM2UINT', 'UINT2NUM' ],
+      'unsigned'      => [ 'NUM2UINT', 'UINT2NUM' ],
+      # Can't do these converters because they conflict with the above:
+      # ID2SYM(x), SYM2ID(x), NUM2DBL(x), FIX2UINT(x)
+    }
+
+    def ruby2c(type)
+      raise "Unknown type #{type}" unless @@type_map.has_key? type
+      @@type_map[type].first
+    end
+
+    def c2ruby(type)
+      raise "Unknown type #{type}" unless @@type_map.has_key? type
+      @@type_map[type].last
+    end
+
+    def strip_comments(src)
+      # strip c-comments
+      src = src.gsub(/\s*(?:(?:\/\*)(?:(?:(?!\*\/)[\s\S])*)(?:\*\/))/, '')
+      # strip cpp-comments
+      src.gsub!(/\s*(?:\/\*(?:(?!\*\/)[\s\S])*\*\/|\/\/[^\n]*\n)/, '')
+      src
+    end
+    
+    def parse_signature(src, raw=false)
+
+      sig = self.strip_comments(src)
+      # strip preprocessor directives
+      sig.gsub!(/^\s*\#.*(\\\n.*)*/, '')
+      # strip {}s
+      sig.gsub!(/\{[^\}]*\}/, '{ }')
+      # clean and collapse whitespace
+      sig.gsub!(/\s+/, ' ')
+
+      types = 'void|VALUE|' + @@type_map.keys.map{|x| Regexp.escape(x)}.join('|')
+
+      if /(#{types})\s*(\w+)\s*\(([^)]*)\)/ =~ sig then
+	return_type, function_name, arg_string = $1, $2, $3
+	args = []
+	arg_string.split(',').each do |arg|
+
+	  # helps normalize into 'char * varname' form
+	  arg = arg.gsub(/\s*\*\s*/, ' * ').strip
+
+	  # if /(#{types})\s+(\w+)\s*$/ =~ arg
+	  if /(((#{types})\s*\*?)+)\s+(\w+)\s*$/ =~ arg then
+	    args.push([$4, $1])
+	  elsif arg != "void" then
+	    $stderr.puts "WARNING: '#{arg}' not understood"
+	  end
+	end
+
+	arity = args.size
+	arity = -1 if arity > MAGIC_ARITY_THRESHOLD or raw
+
+	return {
+	  'return' => return_type,
+	    'name' => function_name,
+	    'args' => args,
+	   'arity' => arity
+	}
+      end
+
+      raise "Bad parser exception: #{sig}"
+    end # def parse_signature
+
+    def generate(src, expand_types=true)
+
+      result = self.strip_comments(src)
+
+      signature = parse_signature(src, !expand_types)
+      function_name = signature['name']
+      return_type = signature['return']
+      arity = signature['arity']
+
+      if expand_types then
+	prefix = "static VALUE #{function_name}("
+	if arity == MAGIC_ARITY then
+	  prefix += "int argc, VALUE *argv, VALUE self"
+	else
+	  prefix += "VALUE self"
+	  signature['args'].each do |arg, type|
+	    prefix += ", VALUE _#{arg}"
+	  end
+	end
+	prefix += ") {\n"
+	if arity == MAGIC_ARITY then
+	  count = 0
+	  signature['args'].each do |arg, type|
+	    prefix += "  #{type} #{arg} = #{ruby2c(type)}(argv[#{count}]);\n"
+	    count += 1
+	  end
+	else
+	  signature['args'].each do |arg, type|
+	    prefix += "  #{type} #{arg} = #{ruby2c(type)}(_#{arg});\n"
+	  end
+	end
+	# replace the function signature (hopefully) with new signature (prefix)
+	result.sub!(/[^;\/\"\>]+#{function_name}\s*\([^\{]+\{/, "\n" + prefix)
+	result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
+	unless return_type == "void" then
+	  raise "couldn't find return statement for #{function_name}" unless 
+	    result =~ /return/ 
+	  result.gsub!(/return\s+([^\;\}]+)/) do
+	    "return #{c2ruby(return_type)}(#{$1})"
+	  end
+	else
+	  result.sub!(/\s*\}\s*\Z/, "\nreturn Qnil;\n}")
+	end
+      else
+	prefix = "static #{return_type} #{function_name}("
+	result.sub!(/[^;\/\"\>]+#{function_name}\s*\(/, prefix)
+	result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
+      end
+
+      @src << result
+      @sig[function_name] = arity
+
+      return result if $TESTING
+    end # def generate
+
+    attr_accessor :mod, :src, :sig, :flags, :libs if $TESTING
+
+    public
+
+    def load
+      require "#{@so_name}" or raise "require on #{@so_name} failed"
+      @mod.class_eval "include #{@mod_name}"
+    end
+
+    def build
+      rb_file = File.expand_path(caller[1].split(/:/).first) # [MS]
+
+      unless File.file? @so_name and File.mtime(rb_file) < File.mtime(@so_name)
+	
+	src_name = "#{Inline.directory}/#{@mod_name}.c"
+	old_src_name = "#{src_name}.old"
+	should_compare = File.write_with_backup(src_name) do |io|
+	  io.puts
+	  io.puts "#include \"ruby.h\""
+	  io.puts
+	  io.puts @src.join("\n\n")
+	  io.puts
+	  io.puts
+	  io.puts "  VALUE c#{@mod_name};"
+	  io.puts "#ifdef __cplusplus"
+	  io.puts "extern \"C\" {"
+	  io.puts "#endif"
+	  io.puts "  void Init_#{@mod_name}() {"
+	  io.puts "    c#{@mod_name} = rb_define_module(\"#{@mod_name}\");"
+	  @sig.keys.sort.each do |name|
+	    arity = @sig[name]
+	    io.print "   rb_define_method(c#{@mod_name}, \"#{name}\", "
+	    io.puts  "(VALUE(*)(ANYARGS))#{name}, #{arity});"
+	  end
+	  io.puts
+	  io.puts "  }"
+	  io.puts "#ifdef __cplusplus"
+	  io.puts "}"
+	  io.puts "#endif"
+	  io.puts
+	end
+
+	# recompile only if the files are different
+	recompile = true
+	if should_compare and File::compare(old_src_name, src_name, $DEBUG) then
+	  recompile = false
+
+	  # Updates the timestamps on all the generated/compiled files.
+	  # Prevents us from entering this conditional unless the source
+	  # file changes again.
+	  File.utime(Time.now, Time.now, src_name, old_src_name, @so_name)
+	end
+
+	if recompile then
+
+	  # extracted from mkmf.rb
+	  srcdir  = Config::CONFIG["srcdir"]
+	  archdir = Config::CONFIG["archdir"]
+	  if File.exist? archdir + "/ruby.h" then
+	    hdrdir = archdir
+	  elsif File.exist? srcdir + "/ruby.h" then
+	    hdrdir = srcdir
+	  else
+	    $stderr.puts "ERROR: Can't find header files for ruby. Exiting..."
+	    exit 1
+	  end
+
+	  flags = @flags.join(' ')
+	  flags += " #{$INLINE_FLAGS}" if defined? $INLINE_FLAGS# DEPRECATE
+	  libs  = @libs.join(' ')
+	  libs += " #{$INLINE_LIBS}" if defined? $INLINE_LIBS	# DEPRECATE
+
+	  cmd = "#{Config::CONFIG['LDSHARED']} #{flags} #{Config::CONFIG['CFLAGS']} -I #{hdrdir} -o #{@so_name} #{src_name} #{libs}"
+	  
+	  if /mswin32/ =~ RUBY_PLATFORM then
+	    cmd += " -link /INCREMENTAL:no /EXPORT:Init_#{@mod_name}"
+	  end
+	  
+	  $stderr.puts "Building #{@so_name} with '#{cmd}'" if $DEBUG
+	  `#{cmd}`
+	  raise "error executing #{cmd}: #{$?}" if $? != 0
+	  $stderr.puts "Built successfully" if $DEBUG
+	end
+
+      else
+	$stderr.puts "#{@so_name} is up to date" if $DEBUG
+      end # unless (file is out of date)
+    end # def build
+      
+    def initialize(mod)
+      @mod = mod
+      @mod_name = "Mod_#{@mod}"
+      @so_name = "#{Inline.directory}/#{@mod_name}.#{Config::CONFIG["DLEXT"]}"
+      @src = []
+      @sig = {}
+      @flags = []
+      @libs = []
+    end
+
+    # Adds compiler options to the compiler command line.  No
+    # preprocessing is done, so you must have all your dashes and
+    # everything.
+    
+    def add_compile_flags(*flags)
+      @flags.push(*flags)
+    end
+
+    # Adds linker flags to the link command line.  No preprocessing is
+    # done, so you must have all your dashes and everything.
+    
+    def add_link_flags(*flags)
+      @libs.push(*flags)
+    end
+
+    # Registers C type-casts <tt>r2c</tt> and <tt>c2r</tt> for
+    # <tt>type</tt>.
+    
+    def add_type_converter(type, r2c, c2r)
+      $stderr.puts "WARNING: overridding #{type}" if @@type_map.has_key? type
+      @@type_map[type] = [r2c, c2r]
+    end
+
+    # Adds an include to the top of the file. Don't forget to use
+    # quotes or angle brackets.
+    
+    def include(header)
+      @src << "#include #{header}"
+    end
+
+    # Adds any amount of text/code to the source
+    
+    def prefix(code)
+      @src << code
+    end
+
+    # Adds a C function to the source, including performing automatic
+    # type conversion to arguments and the return value. Unknown type
+    # conversions can be extended by using +add_type_converter+.
+    
+    def c src
+      self.generate(src)
+    end
+    
+    # Adds a raw C function to the source. This version does not
+    # perform any type conversion and must conform to the ruby/C
+    # coding conventions.
+    
+    def c_raw src
+      self.generate(src, false)
+    end
+
+  end # class Inline::C
+end # module Inline
+
+class Module
+
+  # Extends the Module class to have an inline method. The default
+  # language/builder used is C, but can be specified with the +lang+
+  # parameter.
+  
+  def inline(lang = :C, testing=false)
+    require "inline/#{lang}" unless lang == :C
+    builder = Inline.const_get(lang).new self
+
+    yield builder
+
+    unless testing then
+      builder.build
+      builder.load
+    end
+  end
+end
+
+class File
+
+  # Equivalent to <tt>File::open</tt> with an associated block, but moves
+  # any existing file with the same name to the side first.
+  
+  def self.write_with_backup(path) # returns true if file already existed
+    
+    # move previous version to the side if it exists
+    renamed = false
+    if test ?f, path then
+      renamed = true
+      File.rename path, path + ".old"
+    end
+
+    File.open(path, "w") do |io|
+      yield(io)
+    end
+
+    return renamed
+  end
+
+end # class File
+
+class Dir
+
+  # +assert_secure+ checks to see that +path+ exists and has minimally
+  # writable permissions. If not, it prints an error and exits. It
+  # only works on +POSIX+ systems. Patches for other systems are
+  # welcome.
+  
+  def self.assert_secure(path)
+    mode = File.stat(path).mode
+    unless ((mode % 01000) & 0022) == 0 then
+      if $TESTING then
+	raise 'InsecureDir'
+      else
+	$stderr.puts "#{path} is insecure (#{sprintf('%o', mode)}), needs 0700 for perms"
+	exit 1
+      end
+    end
+  end
+end

data/test_inline.rb

@@ -0,0 +1,481 @@
+#!/usr/bin/ruby -w 
+
+$TESTING = true
+
+require 'inline'
+require 'test/unit'
+
+File.umask(0)
+
+#class TestFile < Test::Unit::TestCase
+# TODO def test_write_with_backup
+#end
+
+class TestDir < Test::Unit::TestCase
+
+  def setup
+    @dir = "/tmp/#{$$}"
+    @count = 1
+    Dir.mkdir @dir, 0700
+  end
+
+  def teardown
+    `rm -rf #{@dir}` unless $DEBUG
+  end
+
+  def util_assert_secure(perms, should_pass)
+    path = File.join(@dir, @count.to_s)
+    @count += 1
+    Dir.mkdir path, perms unless perms.nil?
+    if should_pass then
+      assert_nothing_raised do
+	Dir.assert_secure path
+      end
+    else
+      assert_raises(perms.nil? ? Errno::ENOENT : RuntimeError) do
+	Dir.assert_secure path
+      end
+    end
+  end
+
+  def test_assert_secure
+    # existing/good
+    util_assert_secure 0700, true
+    # existing/bad
+    util_assert_secure 0707, false
+    util_assert_secure 0770, false
+    util_assert_secure 0777, false
+    # missing
+    util_assert_secure nil, false
+  end
+end
+
+class TestInline < Test::Unit::TestCase
+
+  def setup
+    @rootdir = "/tmp/#{$$}"
+    Dir.mkdir @rootdir, 0700
+    ENV['INLINEDIR'] = @rootdir
+  end
+
+  def teardown
+    `rm -rf #{@rootdir}` unless $DEBUG
+  end
+
+  def test_rootdir
+    assert_equal(@rootdir, Inline.rootdir)
+  end
+
+  def test_directory
+    inlinedir = File.join(@rootdir, ".ruby_inline")
+    assert_equal(inlinedir, Inline.directory)
+  end
+
+end
+
+class TestInline
+class TestC < Test::Unit::TestCase
+
+  # quick hack to make tests more readable,
+  # does nothing I wouldn't otherwise do...
+  def inline(lang=:C)
+    self.class.inline(lang, true) do |builder|
+      yield(builder)
+    end
+  end
+
+  def test_initialize
+    x = Inline::C.new(self.class)
+    assert_equal TestInline::TestC, x.mod
+    assert_equal [], x.src
+    assert_equal({}, x.sig)
+    assert_equal [], x.flags
+    assert_equal [], x.libs
+  end
+
+  def test_ruby2c
+    x = Inline::C.new(nil)
+    assert_equal 'NUM2CHR',  x.ruby2c("char")
+    assert_equal 'STR2CSTR', x.ruby2c("char *")
+    assert_equal 'FIX2INT',  x.ruby2c("int")
+    assert_equal 'NUM2INT',  x.ruby2c("long")
+    assert_equal 'NUM2UINT', x.ruby2c("unsigned int")
+    assert_equal 'NUM2UINT', x.ruby2c("unsigned long")
+    assert_equal 'NUM2UINT', x.ruby2c("unsigned")
+
+    assert_raises RuntimeError do
+      x.ruby2c('blah')
+    end
+  end
+
+  def test_c2ruby
+    x = Inline::C.new(nil)
+    assert_equal 'CHR2FIX',     x.c2ruby("char")
+    assert_equal 'rb_str_new2', x.c2ruby("char *")
+    assert_equal 'INT2FIX',     x.c2ruby("int")
+    assert_equal 'INT2NUM',     x.c2ruby("long")
+    assert_equal 'UINT2NUM',    x.c2ruby("unsigned int")
+    assert_equal 'UINT2NUM',    x.c2ruby("unsigned long")
+    assert_equal 'UINT2NUM',    x.c2ruby("unsigned")
+
+    assert_raises RuntimeError do
+      x.c2ruby('blah')
+    end
+  end
+
+  def util_parse_signature(src, expected, t=nil, a=nil, b=nil)
+    
+    result = nil
+    inline do |builder|
+      builder.add_type_converter t, a, b unless t.nil?
+      result = builder.parse_signature(src)
+    end
+    
+    assert_equal(expected, result)
+  end
+
+  def test_parse_signature
+    src = "// stupid cpp comment
+    #include \"header.h\"
+    /* stupid c comment */
+    int
+    add(int x, int y) {
+      int result = x+y;
+      return result;
+    }
+    "
+
+    expected = {
+      'name' => 'add',
+      'return' => 'int',
+      'arity' => 2,
+      'args' => [
+	['x', 'int'],
+	['y', 'int']
+      ]
+    }
+    
+    util_parse_signature(src, expected)
+  end
+  
+  def test_parse_signature_custom
+    
+    src = "// stupid cpp comment
+    #include \"header.h\"
+    /* stupid c comment */
+    int
+    add(fooby x, int y) {
+      int result = x+y;
+      return result;
+    }
+    "
+    
+    expected = {
+      'name' => 'add',
+      'return' => 'int',
+      'arity' => 2,
+      'args' => [
+	[ 'x', 'fooby' ],
+	['y', 'int']
+      ]
+    }
+    
+    util_parse_signature(src, expected,
+			 "fooby", "r2c_fooby", "c2r_fooby") 
+  end
+
+  def test_parse_signature_register
+
+    src = "// stupid cpp comment
+    #include \"header.h\"
+    /* stupid c comment */
+    int
+    add(register int x, int y) {
+      int result = x+y;
+      return result;
+    }
+    "
+
+    expected = {
+      'name' => 'add',
+      'return' => 'int',
+      'arity' => 2,
+      'args' => [
+	[ 'x', 'register int' ],
+	['y', 'int']
+      ]
+    }
+
+    
+    util_parse_signature(src, expected,
+			 "register int", 'FIX2INT', 'INT2FIX')
+  end
+
+  def util_generate(src, expected, expand_types=true)
+    result = ''
+    inline do |builder|
+      result = builder.generate src, expand_types
+    end
+    assert_equal(expected, result)
+  end
+
+  def util_generate_raw(src, expected)
+    util_generate(src, expected, false)
+  end
+
+  # Ruby Arity Rules, from the mouth of Matz:
+  # -2 = ruby array argv
+  # -1 = c array argv
+  #  0 = self
+  #  1 = self, value
+  #  2 = self, value, value
+  # ...
+  # 16 = self, value * 15
+
+  def test_generate_raw_arity_0
+    src = "VALUE y(VALUE self) {blah;}"
+
+    expected = "static VALUE y(VALUE self) {blah;}"
+
+    util_generate_raw(src, expected)
+  end
+
+  def test_generate_arity_0
+    src = "int y() { do_something; return 42; }"
+
+    expected = "static VALUE y(VALUE self) {\n do_something; return INT2FIX(42); }"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_arity_0_no_return
+    src = "void y() { do_something; }"
+
+    expected = "static VALUE y(VALUE self) {\n do_something;\nreturn Qnil;\n}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_arity_0_void_return
+    src = "void y(void) {go_do_something_external;}"
+
+    expected = "static VALUE y(VALUE self) {
+go_do_something_external;\nreturn Qnil;\n}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_arity_0_int_return
+    src = "int x() {return 42}"
+
+    expected = "static VALUE x(VALUE self) {
+return INT2FIX(42)}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_raw_arity_1
+    src = "VALUE y(VALUE self, VALUE obj) {blah;}"
+
+    expected = "static VALUE y(VALUE self, VALUE obj) {blah;}"
+
+    util_generate_raw(src, expected)
+  end
+
+  def test_generate_arity_1
+    src = "int y(int x) {blah; return x+1;}"
+
+    expected = "static VALUE y(VALUE self, VALUE _x) {\n  int x = FIX2INT(_x);\nblah; return INT2FIX(x+1);}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_arity_1_no_return
+    src = "void y(int x) {blah;}"
+
+    expected = "static VALUE y(VALUE self, VALUE _x) {\n  int x = FIX2INT(_x);\nblah;\nreturn Qnil;\n}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_raw_arity_2
+    src = "VALUE func(VALUE self, VALUE obj1, VALUE obj2) {blah;}"
+
+    expected = "static VALUE func(VALUE self, VALUE obj1, VALUE obj2) {blah;}"
+
+    util_generate_raw(src, expected)
+  end
+
+  def test_generate_arity_2
+    src = "int func(int x, int y) {blah; return x+y;}"
+
+    expected = "static VALUE func(VALUE self, VALUE _x, VALUE _y) {\n  int x = FIX2INT(_x);\n  int y = FIX2INT(_y);\nblah; return INT2FIX(x+y);}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_raw_arity_3
+    src = "VALUE func(VALUE self, VALUE obj1, VALUE obj2, VALUE obj3) {blah;}"
+
+    expected = "static VALUE func(VALUE self, VALUE obj1, VALUE obj2, VALUE obj3) {blah;}"
+
+    util_generate_raw(src, expected)
+  end
+
+  def test_generate_arity_3
+    src = "int func(int x, int y, int z) {blah; return x+y+z;}"
+
+    expected = "static VALUE func(int argc, VALUE *argv, VALUE self) {\n  int x = FIX2INT(argv[0]);\n  int y = FIX2INT(argv[1]);\n  int z = FIX2INT(argv[2]);\nblah; return INT2FIX(x+y+z);}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_comments
+    src = "// stupid cpp comment
+    /* stupid c comment */
+    int
+    add(int x, int y) { // add two numbers
+      return x+y;
+    }
+    "
+
+    expected = "static VALUE add(VALUE self, VALUE _x, VALUE _y) {
+  int x = FIX2INT(_x);
+  int y = FIX2INT(_y);
+      return INT2FIX(x+y);
+    }
+    "
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_local_header
+    src = "// stupid cpp comment
+#include \"header\"
+/* stupid c comment */
+int
+add(int x, int y) { // add two numbers
+  return x+y;
+}
+"
+    # FIX: should be 2 spaces before the return. Can't find problem.
+    expected = "#include \"header\"
+static VALUE add(VALUE self, VALUE _x, VALUE _y) {
+  int x = FIX2INT(_x);
+  int y = FIX2INT(_y);
+  return INT2FIX(x+y);
+}
+"
+    util_generate(src, expected)
+  end
+
+  def test_generate_system_header
+    src = "// stupid cpp comment
+#include <header>
+/* stupid c comment */
+int
+add(int x, int y) { // add two numbers
+  return x+y;
+}
+"
+    expected = "#include <header>
+static VALUE add(VALUE self, VALUE _x, VALUE _y) {
+  int x = FIX2INT(_x);
+  int y = FIX2INT(_y);
+  return INT2FIX(x+y);
+}
+"
+    util_generate(src, expected)
+  end
+
+  def test_generate_wonky_return
+    src = "unsigned\nlong z(void) {return 42}"
+
+    expected = "static VALUE z(VALUE self) {
+return UINT2NUM(42)}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_compact
+    src = "int add(int x, int y) {return x+y}"
+
+    expected = "static VALUE add(VALUE self, VALUE _x, VALUE _y) {
+  int x = FIX2INT(_x);
+  int y = FIX2INT(_y);
+return INT2FIX(x+y)}"
+
+    util_generate(src, expected)
+  end
+
+  def test_generate_char_star_normalize
+    src = "char\n\*\n  blah(  char*s) {puts(s); return s}"
+
+    expected = "static VALUE blah(VALUE self, VALUE _s) {
+  char * s = STR2CSTR(_s);
+puts(s); return rb_str_new2(s)}"
+
+    util_generate(src, expected)
+  end
+
+  def test_c
+    builder = result = nil
+    inline(:C) do |b|
+      builder = b
+      result = builder.c "int add(int a, int b) { return a + b; }"
+    end
+
+    expected = "static VALUE add(VALUE self, VALUE _a, VALUE _b) {\n  int a = FIX2INT(_a);\n  int b = FIX2INT(_b);\n return INT2FIX(a + b); }"
+
+    assert_equal expected, result
+    assert_equal [expected], builder.src
+  end
+
+  def test_c_raw
+    src = "static VALUE answer_raw(int argc, VALUE *argv, VALUE self) { return INT2NUM(42); }"
+    builder = result = nil
+    inline(:C) do |b|
+      builder = b
+      result = builder.c_raw src.dup
+    end
+
+    expected = src
+
+    assert_equal expected, result
+    assert_equal [expected], builder.src
+  end
+
+  # I have _no_ idea how to test these
+  # TODO def test_build
+  # TODO def test_load
+
+end # class TestC
+end # class TestInline
+
+class TestModule < Test::Unit::TestCase
+
+  def setup
+    @rootdir = "/tmp/#{$$}"
+    ENV['INLINEDIR'] = @rootdir
+  end
+
+  def teardown
+    `rm -rf #{@rootdir}` unless $DEBUG
+  end
+
+  def test_inline
+    self.class.inline(:C) do |builder|
+      builder.c "int add(int a, int b) { return a + b; }"
+    end
+    assert(test(?d, Inline.directory),
+	   "inline dir should have been created")
+    assert(test(?f, File.join(Inline.directory, "Mod_TestModule.c")),
+	   "Source should have been created")
+    assert(test(?f, File.join(Inline.directory,
+			      "Mod_TestModule.#{Config::CONFIG["DLEXT"]}")),
+	   "Source should have been created")
+  end
+
+end
+
+# Number of errors detected: 4