daikini-octave-ruby 1.0.9

data/test/driver/native/test_conversions.rb

@@ -0,0 +1,203 @@
+$:.unshift File.dirname(__FILE__) + "/../../../lib"
+require 'test/unit'
+require 'octave'
+require 'octave/driver/native/driver'
+require 'rubygems'
+require 'mocha'
+require 'yaml'
+
+class ConversionsTest < Test::Unit::TestCase
+  def setup
+    @driver = Octave::Driver::Native::Driver.new
+    @driver.feval "eval", "function r = to_octave(val); r = val; endfunction"
+  end
+  
+  def to_octave_to_ruby(value)
+    @driver.feval "to_octave", value
+  end
+  
+  def assert_octave_and_ruby_equal(value)
+    result = to_octave_to_ruby(value)
+    assert_equal value, result
+    assert_equal value.class, result.class
+  end
+  
+  def test_should_convert_string
+    assert_octave_and_ruby_equal "foo"
+  end
+  
+  def test_should_convert_true
+    assert_octave_and_ruby_equal true
+  end
+  
+  def test_should_convert_false
+    assert_octave_and_ruby_equal false
+  end
+  
+  def test_should_convert_nil
+    assert_octave_and_ruby_equal nil
+  end
+  
+  def test_should_convert_float
+    assert_octave_and_ruby_equal 12.345
+  end
+  
+  def test_should_convert_fixnum
+    # Fixnums are sent to and returned from Octave as Float
+    result = to_octave_to_ruby(12345)
+    assert_equal 12345.0, result
+    assert_instance_of Float, result
+  end
+  
+  def test_should_convert_array_from_and_to
+    assert_octave_and_ruby_equal [1, nil, 3.0]
+    assert_octave_and_ruby_equal [1, "2", false, ["foo", "bar", "baz"]]
+  end
+  
+  def test_should_convert_hash_from_and_to
+    assert_octave_and_ruby_equal "foo" => "bar"
+    assert_octave_and_ruby_equal "foo" => [1,2,3]
+    assert_octave_and_ruby_equal "foo" => { "bar" => [1,2,3, [4,5,6]] }
+    assert_octave_and_ruby_equal "foo" => { "bar" => [1,2,3, [4,5,6]], "baz" => "buz", "bob" => [7,8,9] }
+  end
+  
+  def test_should_be_able_to_reference_structure_fields_from_hash
+    hash = { "foo" => { "bar" => [1,2,3, [4,5,6]] }, "baz" => { "buz" => [7,8,9] } }
+    @driver.put_variable "hash", hash
+    assert_equal hash["foo"]["bar"], @driver.feval("eval", "hash.foo.bar")
+    assert_equal hash["baz"]["buz"], @driver.feval("eval", "hash.baz.buz")
+  end
+  
+  def test_should_be_able_to_reference_structure_fields_from_octave_struct_matrix
+    bar_matrix = Octave::StructMatrix.new(1, 1, "bar")
+    bar_matrix[0,0]["bar"] = [1,2,3, [4,5,6]]
+    
+    struct_matrix = Octave::StructMatrix.new(1, 1, "foo")
+    struct_matrix[0,0]["foo"] = bar_matrix
+    
+    @driver.put_variable "struct_matrix", struct_matrix
+    assert_equal [1,2,3, [4,5,6]], @driver.feval("eval", "struct_matrix.foo.bar")
+  end
+  
+  def test_should_convert_octave_matrix
+    matrix = Octave::Matrix.new(3, 3)
+    3.times { |m| 3.times { |n| matrix[m, n] = rand } }
+    matrix[1, 1] = nil
+    
+    assert_octave_and_ruby_equal matrix
+  end
+  
+  def test_should_convert_a_0x0_octave_matrix_to_an_empty_array
+    matrix = Octave::Matrix.new(0, 0)
+    
+    expected_array = []
+    result = to_octave_to_ruby(matrix)
+    
+    assert_equal expected_array, result
+    assert_instance_of Array, result
+  end
+  
+  def test_should_convert_an_empty_ruby_array
+    assert_octave_and_ruby_equal []
+  end
+  
+  def test_should_convert_a_1xn_octave_matrix_to_an_octave_matrix
+    matrix = Octave::Matrix.new(1, 3)
+    matrix[0, 0] = 1
+    matrix[0, 1] = 2
+    matrix[0, 2] = 3
+    
+    result = @driver.put_variable "octave_matrix", matrix
+
+    assert_instance_of Octave::Matrix, result
+    assert_equal matrix, result
+    assert_equal 1, @driver.feval("rows", result)
+    assert_equal 3, @driver.feval("columns", result)
+  end
+  
+  def test_should_convert_an_nx1_octave_matrix_to_an_array
+    matrix = Octave::Matrix.new(3, 1)
+    matrix[0, 0] = 1
+    matrix[1, 0] = 2
+    matrix[2, 0] = 3
+    
+    expected_array = [1,2,3]
+    result = to_octave_to_ruby(matrix)
+    
+    assert_equal expected_array, result
+    assert_instance_of Array, result
+    assert_equal 3, @driver.feval("rows", result)
+    assert_equal 1, @driver.feval("columns", result)
+  end
+  
+  def test_should_convert_octave_struct_matrix
+    struct_matrix = Octave::StructMatrix.new(17, 2, "name", "age", "married", "cats", "car")
+    17.times do |m|
+      2.times do |n|
+        struct_matrix[m, n]["name"] = "Bob #{m}.#{n}"
+        struct_matrix[m, n]["age"] = (rand * 100).to_i
+        struct_matrix[m, n]["married"] = (rand > 0.5)
+        struct_matrix[m, n]["cats"] = { "name" => "Kitty #{m}.#{n}" }
+        struct_matrix[m, n]["car"] = nil
+      end
+    end
+    
+    assert_octave_and_ruby_equal struct_matrix
+  end
+  
+  def test_should_convert_a_1x1_struct_matrix_to_a_hash
+    struct_matrix = Octave::StructMatrix.new(1, 1, "foo")
+    struct_matrix[0,0]["foo"] = { "bar" => [1,2,3] }
+    
+    expected_hash = { "foo" => { "bar" => [1,2,3] } }
+    result = to_octave_to_ruby(struct_matrix)
+    
+    assert_equal expected_hash, result
+    assert_instance_of Hash, result
+  end
+  
+  def test_should_convert_octave_cell_matrix
+    cell_matrix = Octave::CellMatrix.new(3, 3)
+    cell_matrix[0, 0] = 1
+    cell_matrix[1, 0] = "2"
+    cell_matrix[2, 0] = false
+    
+    assert_octave_and_ruby_equal cell_matrix
+  end
+  
+  def test_should_convert_a_1x1_cell_matrix_to_value
+    cell_matrix = Octave::CellMatrix.new(1, 1)
+    cell_matrix[0,0] = [1, 2, 3]
+    
+    assert_equal [1, 2, 3], to_octave_to_ruby(cell_matrix)
+  end
+  
+  def test_should_convert_a_1xn_cell_matrix_to_an_octave_cell_matrix
+    cell_matrix = Octave::CellMatrix.new(1, 3)
+    cell_matrix[0,0] = "foo"
+    cell_matrix[0,1] = "bar"
+    cell_matrix[0,2] = "baz"
+    
+    result = @driver.put_variable "octave_cell_matrix", cell_matrix
+
+    assert_instance_of Octave::CellMatrix, result
+    assert_equal cell_matrix, result
+    assert_equal 1, @driver.feval("rows", result)
+    assert_equal 3, @driver.feval("columns", result)
+  end
+  
+  def test_should_convert_a_nx1_cell_matrix_to_an_array
+    cell_matrix = Octave::CellMatrix.new(3, 1)
+    cell_matrix[0,0] = "foo"
+    cell_matrix[1,0] = "bar"
+    cell_matrix[2,0] = "baz"
+    
+    assert_equal %w(foo bar baz), to_octave_to_ruby(cell_matrix)
+  end
+  
+  def test_should_convert_boolean_matrix
+    assert_octave_and_ruby_equal [true, false, true]
+    boolean_matrix = @driver.feval "eval", "x = [1,2]; (x > 2 | x < 2)"
+    assert_equal [true, false], boolean_matrix
+  end
+end

data/test/driver/native/test_driver.rb

@@ -0,0 +1,32 @@
+$:.unshift "../../../lib"
+require 'test/unit'
+require 'octave'
+require 'octave/driver/native/driver'
+require 'rubygems'
+require 'mocha'
+
+class DriverTest < Test::Unit::TestCase
+  include Octave::Driver::Native
+  
+  def setup
+    @driver = Driver.new
+  end
+  
+  def test_feval
+    API.expects(:feval).with("some_function_name", ["argument 1", "argument 2"])
+    @driver.feval("some_function_name", "argument 1", "argument 2")
+  end
+  
+  def test_put_and_get_variable
+    assert_equal "some_value", @driver.put_variable("some_variable_name", "some_value")
+    assert_equal "some_value", @driver.get_variable("some_variable_name")
+  end
+  
+  def test_putting_variable_with_same_name_multiple_times
+    assert_equal "foo", @driver.put_variable("some_variable_name", "foo")
+    assert_equal "bar", @driver.put_variable("some_variable_name", "bar")
+    assert_equal "baz", @driver.put_variable("some_variable_name", "baz")
+    
+    assert_equal "baz", @driver.get_variable("some_variable_name")
+  end
+end

data/test/test_engine.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'octave'
+require 'octave/engine'
+require 'rubygems'
+require 'mocha'
+
+class Driver
+end
+
+class EngineTest_Init < Test::Unit::TestCase
+  def test_new
+    driver = mock()
+    Driver.expects(:new).returns(driver)
+    
+    engine = Octave::Engine.new(:driver => Driver)
+  end
+  
+  def test_new_with_invalid_driver
+    exception = assert_raise(LoadError) do
+      engine = Octave::Engine.new(:driver => "foo")
+    end
+    assert_equal "no such file to load -- octave/driver/foo/driver", exception.message
+    
+    exception = assert_raise(LoadError) do
+      engine = Octave::Engine.new(:driver => :bar)
+    end
+    assert_equal "no such file to load -- octave/driver/bar/driver", exception.message
+  end
+  
+  def test_new_with_native_driver
+    assert_nothing_raised do
+      engine = Octave::Engine.new
+    end
+  end
+end
+
+class EngineTest < Test::Unit::TestCase
+  def setup
+    @driver = mock()
+    @handle = mock()
+    Driver.expects(:new).returns(@driver)
+    
+    @engine = Octave::Engine.new(:driver => Driver)
+  end
+  
+  def test_method_missing
+    @driver.expects(:feval).with("some_method_name", "argument 1", "argument 2")
+    @engine.some_method_name("argument 1", "argument 2")
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: daikini-octave-ruby
+version: !ruby/object:Gem::Version 
+  version: 1.0.9
+platform: ruby
+authors: 
+- Jonathan Younger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-30 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: "== USAGE:  require 'octave'  engine = Octave::Engine.new engine.eval \"123.456 * 789.101112\" engine.rand(10)  matrix = Octave::Matrix.new(20, 400) 20.times { |m| 400.times { |n| matrix[m, n] = rand } } engine.put_variable(\"m\", matrix)  engine.save \"/tmp/20_x_400_matrix\"  == REQUIREMENTS:  * Octave * GCC or some other compiler to build the included extension * Mocha (For testing only)"
+email: 
+- jonathan@daikini.com
+executables: []
+
+extensions: 
+- ext/octave_api/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- ext/octave_api/MANIFEST
+- ext/octave_api/Makefile
+- ext/octave_api/extconf.rb
+- ext/octave_api/octave-includes.h
+- ext/octave_api/octave-ruby.cpp
+- ext/octave_api/octave-ruby.h
+- ext/octave_api/octave_api.c
+- ext/octave_api/octave_api.h
+- ext/octave_api/or-array.cpp
+- ext/octave_api/or-array.h
+- ext/octave_api/or-boolean_matrix.cpp
+- ext/octave_api/or-boolean_matrix.h
+- ext/octave_api/or-cell_matrix.cpp
+- ext/octave_api/or-cell_matrix.h
+- ext/octave_api/or-hash.cpp
+- ext/octave_api/or-hash.h
+- ext/octave_api/or-matrix.cpp
+- ext/octave_api/or-matrix.h
+- ext/octave_api/or-string.cpp
+- ext/octave_api/or-string.h
+- ext/octave_api/or-struct_matrix.cpp
+- ext/octave_api/or-struct_matrix.h
+- ext/octave_api/or-variable.cpp
+- ext/octave_api/or-variable.h
+- lib/octave.rb
+- lib/octave/driver/native/driver.rb
+- lib/octave/engine.rb
+- lib/octave/matrix.rb
+- lib/octave/version.rb
+- octave-ruby.gemspec
+- setup.rb
+- test/driver/native/test_conversions.rb
+- test/driver/native/test_driver.rb
+- test/test_engine.rb
+has_rdoc: true
+homepage: http://octave-ruby.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: octave-ruby
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Ruby interface to the Octave interpreted language.
+test_files: 
+- test/driver/native/test_conversions.rb
+- test/driver/native/test_driver.rb
+- test/test_engine.rb