ruby-llvm 2.9.1 → 2.9.3

data/test/basic_block_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class BasicBlockTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+    @module = LLVM::Module.new("BasicBlockTestCase")
+  end
+
+  def test_basic_block_collection
+    @module.functions.add("test_basic_block_collection", [], LLVM.Void) do |fn|
+      coll = fn.basic_blocks
+
+      block1 = coll.append
+      assert_instance_of LLVM::BasicBlock, block1
+
+      assert_equal 1, coll.size
+      assert_equal coll.first, coll.last,
+                   'Only one block exists in the function'
+      assert_equal coll.first, coll.entry,
+                   'The entry block for the function is always the first block'
+
+      block2 = coll.append
+      assert_equal 2, coll.size
+      assert_equal block1, coll.first
+      assert_equal block2, coll.last
+
+      [ coll.each.to_a, coll.to_a ].each do |blocks|
+        assert_equal 2, blocks.size
+        assert_equal block1, blocks[0]
+        assert_equal block2, blocks[1]
+      end
+    end
+  end
+
+  def test_basic_block
+    @module.functions.add("test_basic_block", [], LLVM.Void) do |fn|
+      coll = fn.basic_blocks
+
+      block1 = coll.append
+      block2 = coll.append
+
+      assert_equal fn, block1.parent
+      assert_equal fn, block2.parent
+
+      assert_equal block2, block1.next
+      assert_equal block1, block2.previous
+
+      block1.build do |builder|
+        builder.br(block2)
+      end
+
+      block2.build do |builder|
+        builder.ret_void
+      end
+
+      assert_equal block1.first_instruction,
+                   block1.last_instruction
+      assert_equal block2.first_instruction,
+                   block2.last_instruction
+    end
+  end
+
+  def test_basic_block_enumerable
+    @module.functions.add("test_basic_block_enumerable", [LLVM::Double], LLVM::Double) do |fn, arg|
+      block1 = fn.basic_blocks.append
+
+      [ block1.instructions.to_a, block1.instructions.each.to_a ].each do |insts|
+        assert_equal 0, insts.size, 'Empty basic block'
+      end
+
+      block1.build do |builder|
+        builder.ret(builder.fadd(arg, LLVM.Double(1.0)))
+      end
+
+      [ block1.instructions.to_a, block1.instructions.each.to_a ].each do |insts|
+        assert_equal 2, insts.size
+        assert_equal block1.first_instruction, insts[0]  # deprecated
+        assert_equal block1.last_instruction,  insts[1]  # deprecated
+        assert_equal block1.instructions.first, insts[0]
+        assert_equal block1.instructions.last,  insts[1]
+      end
+
+    end
+  end
+
+end
+

data/test/basic_test.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+class BasicTestCase < Test::Unit::TestCase
+
+  def test_llvm_initialization
+    assert_nothing_raised do
+      LLVM.init_x86
+    end
+  end
+
+end

data/test/binary_operations_test.rb

@@ -0,0 +1,58 @@
+require "test_helper"
+
+class BasicOperationsTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_integer_binary_operations
+    integer_binary_operation_assertion(:add, 3, 2, 3 + 2)
+    integer_binary_operation_assertion(:sub, 3, 2, 3 - 2)
+    integer_binary_operation_assertion(:mul, 3, 2, 3 * 2)
+    integer_binary_operation_assertion(:udiv, 10, 2, 10 / 2)
+    integer_binary_operation_assertion(:sdiv, 10, 2, 10 / 2)
+    integer_binary_operation_assertion(:urem, 10, 3, 10 % 3)
+    integer_binary_operation_assertion(:srem, 10, 3, 10 % 3)
+  end
+
+  def test_integer_bitwise_binary_operations
+    integer_binary_operation_assertion(:shl, 2, 3, 2 << 3)
+    integer_binary_operation_assertion(:lshr, 16, 3, 16 >> 3)
+    integer_binary_operation_assertion(:ashr, 16, 3, 16 >> 3)
+    integer_binary_operation_assertion(:and, 2, 1, 2 & 1)
+    integer_binary_operation_assertion(:or, 2, 1, 2 | 1)
+    integer_binary_operation_assertion(:xor, 3, 2, 3 ^ 2)
+  end
+
+  def test_float_binary_operations
+    float_binary_operation_assertion(:fadd, 3.1, 2.2, 3.1 + 2.2)
+    float_binary_operation_assertion(:fsub, 3.1, 2.2, 3.1 - 2.2)
+    float_binary_operation_assertion(:fmul, 3.1, 2.2, 3.1 * 2.2)
+    float_binary_operation_assertion(:fdiv, 3.1, 2.2, 3.1 / 2.2)
+    float_binary_operation_assertion(:frem, 3.1, 2.2, 3.1 % 2.2)
+  end
+
+  def integer_binary_operation_assertion(operation, operand1, operand2, expected_result)
+    result = run_binary_operation(operation,
+                                  LLVM::Int(operand1), LLVM::Int(operand2),
+                                  LLVM::Int).to_i
+    assert_equal expected_result, result
+  end
+
+  def float_binary_operation_assertion(operation, operand1, operand2, expected_result)
+    result = run_binary_operation(operation,
+                                  LLVM::Float(operand1), LLVM::Float(operand2),
+                                  LLVM::Float).to_f
+    assert_in_delta expected_result, result, 0.001
+  end
+
+  def run_binary_operation(operation, operand1, operand2, return_type)
+    run_function([], [], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.send(operation, operand1, operand2))
+    end
+  end
+
+end

data/test/bitcode_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+require "tempfile"
+
+class BitcodeTestCase < Test::Unit::TestCase
+  def setup
+    LLVM.init_x86
+  end
+  
+  def test_bitcode
+    test_module = define_module("test_module") do |mod|
+      define_function(mod, "test_function", [], LLVM::Int) do
+        |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(LLVM::Int(1))
+      end
+    end
+    Tempfile.open("bitcode") do |tmp|
+      assert test_module.write_bitcode(tmp)
+      new_module = LLVM::Module.parse_bitcode(tmp.path)
+      result = run_function_on_module(new_module, "test_function").to_i
+      assert_equal 1, result
+    end
+  end
+end

data/test/branch_test.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+
+class BranchTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_branching
+    assert_equal 0, direct_jump_function().to_i
+    assert_equal 0, conditional_jump_function().to_i
+    assert_equal 0, switched_jump_function().to_i
+  end
+
+  def direct_jump_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      branch_1 = function.basic_blocks.append
+      branch_2 = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.br(branch_2)
+      builder.position_at_end(branch_1)
+      builder.ret(LLVM::Int(1))
+      builder.position_at_end(branch_2)
+      builder.ret(LLVM::Int(0))
+    end
+  end
+
+  def conditional_jump_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      branch_1 = function.basic_blocks.append
+      branch_2 = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.cond(builder.icmp(:eq, LLVM::Int(1), LLVM::Int(2)), branch_1, branch_2)
+      builder.position_at_end(branch_1)
+      builder.ret(LLVM::Int(1))
+      builder.position_at_end(branch_2)
+      builder.ret(LLVM::Int(0))
+    end
+  end
+
+  def switched_jump_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      branch_1 = function.basic_blocks.append
+      branch_2 = function.basic_blocks.append
+      builder.position_at_end(entry)
+      switch = builder.switch(LLVM::Int(1), branch_1, LLVM::Int(1) => branch_2)
+      builder.position_at_end(branch_1)
+      builder.ret(LLVM::Int(1))
+      builder.position_at_end(branch_2)
+      builder.ret(LLVM::Int(0))
+    end
+  end
+
+end

data/test/call_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+class CallTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_simple_call
+    test_module = define_module("test_module") do |host_module|
+      define_function(host_module, "test_function", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(LLVM::Int(1))
+      end
+    end
+    assert_equal 1, run_function_on_module(test_module, "test_function").to_i
+  end
+
+  def test_nested_call
+    test_module = define_module("test_module") do |host_module|
+      function_1 = define_function(host_module, "test_function_1", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(LLVM::Int(1))
+      end
+      function_2 = define_function(host_module, "test_function_2", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(builder.call(function_1))
+      end
+    end
+    assert_equal 1, run_function_on_module(test_module, "test_function_2").to_i
+  end
+
+  def test_recursive_call
+    test_module = define_module("test_module") do |host_module|
+      define_function(host_module, "test_function", [LLVM::Int], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        recurse = function.basic_blocks.append
+        exit = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.cond(builder.icmp(:uge, arguments.first, LLVM::Int(5)), exit, recurse)
+        builder.position_at_end(recurse)
+        result = builder.call(function, builder.add(arguments.first, LLVM::Int(1)))
+        builder.br(exit)
+        builder.position_at_end(exit)
+        builder.ret(builder.phi(LLVM::Int, entry => arguments.first, recurse => result))
+      end
+    end
+    assert_equal 5, run_function_on_module(test_module, "test_function", 1).to_i
+  end
+
+  def test_external
+    test_module = define_module("test_module") do |host_module|
+      external = host_module.functions.add("abs", [LLVM::Int], LLVM::Int)
+      define_function(host_module, "test_function", [LLVM::Int], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(builder.call(external, arguments.first))
+      end
+    end
+    assert_equal -10.abs, run_function_on_module(test_module, "test_function", -10).to_i
+  end
+
+  def test_external_string
+    test_module = define_module("test_module") do |host_module|
+      global = host_module.globals.add(LLVM::Array(LLVM::Int8, 5), "path")
+      global.linkage = :internal
+      global.initializer = LLVM::ConstantArray.string("PATH")
+      external = host_module.functions.add("getenv", [LLVM::Pointer(LLVM::Int8)], LLVM::Pointer(LLVM::Int8))
+      define_function(host_module, "test_function", [], LLVM::Pointer(LLVM::Int8)) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        parameter = builder.gep(global, [LLVM::Int(0), LLVM::Int(0)])
+        builder.ret(builder.call(external, parameter))
+      end
+    end
+    assert_equal ENV["PATH"], run_function_on_module(test_module, "test_function").to_ptr.read_pointer.read_string
+  end
+
+end

data/test/comparisons_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class ComparisonsTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_integer_comparison
+    integer_comparison_assertion(:eq, 1, 1, LLVM_SIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:ne, 1, 1, LLVM_SIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:ugt, 2, 2, LLVM_UNSIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:uge, 2, 1, LLVM_UNSIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:ult, 1, 1, LLVM_UNSIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:ule, 1, 2, LLVM_UNSIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:sgt, -2, 2, LLVM_SIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:sge, -2, 1, LLVM_SIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:slt, -1, 2, LLVM_SIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:sle, -1, 2, LLVM_SIGNED, LLVM_TRUE)
+  end
+
+  def test_float_comparison
+    float_comparison_assertion(:oeq, 1.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:one, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ogt, 2.0, 2.0, LLVM_FALSE)
+    float_comparison_assertion(:oge, 2.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:olt, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ole, 1.0, 2.0, LLVM_TRUE)
+    float_comparison_assertion(:ord, 1.0, 2.0, LLVM_TRUE)
+    float_comparison_assertion(:ueq, 1.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:une, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ugt, 2.0, 2.0, LLVM_FALSE)
+    float_comparison_assertion(:uge, 2.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:ult, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ule, 1.0, 2.0, LLVM_TRUE)
+    float_comparison_assertion(:uno, 1.0, 2.0, LLVM_FALSE)
+  end
+
+  def integer_comparison_assertion(operation, operand1, operand2, signed, expected_result)
+    result = run_comparison_operation(:icmp,
+                                      operation,
+                                      LLVM::Int.from_i(operand1, signed),
+                                      LLVM::Int.from_i(operand2, signed),
+                                      LLVM::Int1).to_i(false)
+    assert_equal expected_result, result
+  end
+
+  def float_comparison_assertion(operation, operand1, operand2, expected_result)
+    result = run_comparison_operation(:fcmp,
+                                      operation,
+                                      LLVM::Float(operand1),
+                                      LLVM::Float(operand2),
+                                      LLVM::Int1).to_i(false)
+    assert_equal expected_result, result
+  end
+
+  def run_comparison_operation(comparison_operation, comparison_operator,
+                               operand1, operand2, return_type)
+    run_function([], [], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.send(comparison_operation, comparison_operator, operand1, operand2))
+    end
+  end
+
+end

data/test/conversions_test.rb

@@ -0,0 +1,86 @@
+require "test_helper"
+
+class ConversionsTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_trunc_to
+    integer_conversion_assertion(:trunc, LLVM::Int32.from_i(257), LLVM::Int8, LLVM_UNSIGNED, 1)
+    integer_conversion_assertion(:trunc, LLVM::Int32.from_i(123), LLVM::Int1, LLVM_UNSIGNED, 1)
+    integer_conversion_assertion(:trunc, LLVM::Int32.from_i(122), LLVM::Int1, LLVM_UNSIGNED, 0)
+  end
+
+  def test_zext_to
+    integer_conversion_assertion(:zext, LLVM::Int16.from_i(257), LLVM::Int32, LLVM_UNSIGNED, 257)
+  end
+
+  def test_sext_to
+    integer_conversion_assertion(:sext, LLVM::Int1.from_i(1), LLVM::Int32, LLVM_SIGNED, -1)
+    integer_conversion_assertion(:sext, LLVM::Int8.from_i(-1), LLVM::Int16, LLVM_UNSIGNED, 65535)
+  end
+
+  def test_fptrunc_to
+    float_conversion_assertion(:fp_trunc, LLVM::Double(123.0), LLVM::Float, 123.0)
+  end
+
+  def test_fpext_to
+    float_conversion_assertion(:fp_ext, LLVM::Float(123.0), LLVM::Double, 123.0)
+    float_conversion_assertion(:fp_ext, LLVM::Float(123.0), LLVM::Float, 123.0)
+  end
+
+  def test_fptoui_to
+    different_type_assertion(:fp2ui, LLVM::Double(123.3), LLVM::Int32, :integer, 123)
+    different_type_assertion(:fp2ui, LLVM::Double(0.7), LLVM::Int32, :integer, 0)
+    different_type_assertion(:fp2ui, LLVM::Double(1.7), LLVM::Int32, :integer, 1)
+  end
+
+  def test_fptosi_to
+    different_type_assertion(:fp2si, LLVM::Double(-123.3), LLVM::Int32, :integer, -123)
+    different_type_assertion(:fp2si, LLVM::Double(0.7), LLVM::Int32, :integer, 0)
+    different_type_assertion(:fp2si, LLVM::Double(1.7), LLVM::Int32, :integer, 1)
+  end
+
+  def test_uitofp_to
+    different_type_assertion(:ui2fp, LLVM::Int32.from_i(257), LLVM::Float, :float, 257.0)
+    different_type_assertion(:ui2fp, LLVM::Int8.from_i(-1), LLVM::Double, :float, 255.0)
+  end
+
+  def test_sitofp_to
+    different_type_assertion(:si2fp, LLVM::Int32.from_i(257), LLVM::Float, :float, 257.0)
+    different_type_assertion(:si2fp, LLVM::Int8.from_i(-1), LLVM::Double, :float, -1.0)
+  end
+
+  def test_bitcast_to
+    different_type_assertion(:bit_cast, LLVM::Int8.from_i(255), LLVM::Int8, :integer, -1)
+  end
+
+  def integer_conversion_assertion(operation, operand, return_type, signed, expected_result)
+    result = run_conversion_operation(operation, operand, return_type)
+    assert_equal expected_result, result.to_i(signed)
+  end
+
+  def float_conversion_assertion(operation, operand, return_type, expected_result)
+    result = run_conversion_operation(operation, operand, return_type)
+    assert_in_delta expected_result, result.to_f(return_type), 0.001
+  end
+
+  def different_type_assertion(operation, operand, return_type, assertion_type, expected_result)
+    result = run_conversion_operation(operation, operand, return_type)
+    if assertion_type == :integer
+      assert_equal expected_result, result.to_i
+    else
+      assert_in_delta expected_result, result.to_f(return_type), 0.001
+    end
+  end
+
+  def run_conversion_operation(operation, operand, return_type)
+    run_function([], [], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.send(operation, operand, return_type))
+    end
+  end
+
+end

data/test/double_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class DoubleTestCase < Test::Unit::TestCase
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_double
+    mod	= LLVM::Module.new("Double Test")
+    mod.functions.add(:sin, [LLVM::Double], LLVM::Double)
+
+    builder = LLVM::Builder.new
+
+    mod.functions.add('test', [LLVM::Double], LLVM::Double) do |fun, p0|
+      p0.name = 'x'
+
+      bb = fun.basic_blocks.append
+      builder.position_at_end(bb)
+      
+      builder.ret(builder.fadd(p0, LLVM::Double(1.0)))
+    end
+
+    engine = LLVM::JITCompiler.new(mod)
+
+    arg	= 5.0
+    result = engine.run_function(mod.functions["test"], arg)
+    assert_equal arg+1, result.to_f(LLVM::Double)
+
+    assert_in_delta(Math.sin(1.0),
+      engine.run_function(mod.functions["sin"], 1.0).to_f(LLVM::Double),
+      1e-10)
+  end
+end

data/test/equality_test.rb

@@ -0,0 +1,91 @@
+require "test_helper"
+require "llvm/core"
+
+class EqualityTestCase < Test::Unit::TestCase
+  def setup
+    LLVM.init_x86
+  end
+
+  class MyModule < LLVM::Module; end
+  class MyInt < LLVM::Int32; end
+  class MyType < LLVM::Type; end
+  class MyFunction < LLVM::Function; end
+
+  def assert_equalities(options)
+    map = {
+      :equal     => method(:assert_equal),
+      :not_equal => method(:assert_not_equal),
+      :same      => method(:assert_same),
+      :not_same  => method(:assert_not_same),
+      :eql       => lambda {|n, m, name| assert n.eql?(m), name },
+      :not_eql   => lambda {|n, m, name| assert !n.eql?(m), name },
+    }
+
+    map.each do |name, callable|
+      options[name].combination(2).each do |n, m|
+        callable.call(n, m, name.to_s)
+      end
+    end
+
+  end
+
+  def test_int_value
+    int1 = LLVM::Int32.from_i(1)
+    int2 = LLVM::Int32.from_ptr(int1.to_ptr)
+    int3 = LLVM::Int32.from_i(2)
+    int4 = MyInt.from_ptr(int1.to_ptr)
+
+    assert_equalities :equal     => [int1, int2, int4],
+                      :not_equal => [int1, int3],
+                      :same      => [int1, int1],
+                      :not_same  => [int1, int2, int3, int4],
+                      :eql       => [int1, int2],
+                      :not_eql   => [int1, int3, int4]
+  end
+
+  def test_module
+    mod1 = LLVM::Module.new('test')
+    mod2 = LLVM::Module.from_ptr(mod1.to_ptr)
+    mod3 = LLVM::Module.new('dummy')
+    mod4 = MyModule.from_ptr(mod1.to_ptr)
+
+    assert_equalities :equal     => [mod1, mod2, mod4],
+                      :not_equal => [mod1, mod3],
+                      :same      => [mod1, mod1],
+                      :not_same  => [mod1, mod2, mod3, mod4],
+                      :eql       => [mod1, mod2],
+                      :not_eql   => [mod1, mod3, mod4]
+  end
+
+  def test_type
+    type1 = LLVM::Float.type
+    type2 = LLVM::Type.from_ptr(type1.to_ptr)
+    type3 = LLVM::Double.type
+    type4 = MyType.from_ptr(type1.to_ptr)
+
+    assert_equalities :equal     => [type1, type2, type4],
+                      :not_equal => [type1, type3],
+                      :same      => [type1, type1],
+                      :not_same  => [type1, type2, type3, type4],
+                      :eql       => [type1, type2],
+                      :not_eql   => [type1, type3, type4]
+  end
+
+  def test_function
+    mod = LLVM::Module.new('test')
+
+    fn1 = mod.functions.add('test1', LLVM.Void)
+    fn2 = LLVM::Function.from_ptr(fn1.to_ptr)
+    fn3 = mod.functions.add('test2', LLVM.Void)
+    fn4 = MyFunction.from_ptr(fn1.to_ptr)
+
+    assert_equalities :equal     => [fn1, fn2, fn4],
+                      :not_equal => [fn1, fn3],
+                      :same      => [fn1, fn1],
+                      :not_same  => [fn1, fn2, fn3, fn4],
+                      :eql       => [fn1, fn2],
+                      :not_eql   => [fn1, fn3, fn4]
+  end
+
+end
+

data/test/generic_value_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class GenericValueTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_from_i
+    assert_equal 2, LLVM::GenericValue.from_i(2).to_i
+    assert_equal 2 ,LLVM::GenericValue.from_i(2.2).to_i
+  end
+
+  def test_from_float
+    assert_in_delta 2.2, LLVM::GenericValue.from_f(2.2).to_f, 1e-6
+  end
+
+  def test_from_double
+    assert_in_delta 2.2, LLVM::GenericValue.from_d(2.2).to_f(LLVM::Double), 1e-6
+  end
+
+end

data/test/instruction_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class InstructionTestCase < Test::Unit::TestCase
+  def setup
+    LLVM.init_x86
+    @module = LLVM::Module.new("InstructionTestCase")
+  end
+
+  def test_instruction
+    fn = @module.functions.add("test_instruction", [LLVM::Double], LLVM::Double) do |fn, arg|
+      fn.basic_blocks.append.build do |builder|
+        builder.ret(
+          builder.fadd(arg, LLVM.Double(3.0)))
+      end
+    end
+
+    entry = fn.basic_blocks.entry
+
+    inst1 = entry.instructions.first
+    inst2 = entry.instructions.last
+
+    assert_kind_of LLVM::Instruction, inst1
+    assert_kind_of LLVM::Instruction, inst2
+
+    assert_equal inst2, inst1.next
+    assert_equal inst1, inst2.previous
+    assert_equal entry, inst1.parent
+    assert_equal entry, inst2.parent
+  end
+end
+
+