asir 0.2.0 → 1.0.1

data/spec/demux_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'asir'
+require 'asir/transport/demux'
+
+require 'asir/transport/buffer'
+
+describe "ASIR::Transport::Demux" do
+  attr_accessor :transport, :object
+
+  before(:each) do
+    self.transport = ASIR::Transport::Demux.new
+    self.transport.transport_proc = lambda do | t, m |
+      m.arguments[0].size % 2 == 0 ? t[:even] : t[:odd]
+    end
+    self.transport[:even] = ASIR::Transport::Buffer.new(:transport => ASIR::Transport::Local.new)
+    self.transport[:even].pause!
+    self.transport[:odd]  = ASIR::Transport::Buffer.new(:transport => ASIR::Transport::Local.new)
+    self.transport[:odd].pause!
+    self.object = ASIR::Test::TestObject.new(self)
+    object.class.asir.transport = transport
+  end
+
+  it 'should direct even-sized arg[0] Arrays to transport[:even].' do
+    result = object.asir.return_argument [ 1, 2 ]
+    transport[:even].size.should == 1
+    transport[:odd].size.should == 0
+    result.should == nil
+  end
+
+  it 'should direct odd-sized arg[0] Arrays to transport[:odd].' do
+    result = object.asir.return_argument [ 1, 2, 3 ]
+    transport[:even].size.should == 0
+    transport[:odd].size.should == 1
+    result.should == nil
+  end
+end
+

data/spec/json_spec.rb

@@ -2,7 +2,6 @@ require File.expand_path('../spec_helper', __FILE__)
 require 'asir/coder/json'
 
 describe "ASIR::Coder::JSON" do
-# unless RUBY_PLATFORM =~ /java/
   before(:each) do 
     @enc = ASIR::Coder::JSON.new
     @dec = @enc.dup
@@ -123,6 +122,5 @@ FIXME:
       y.instance_variables.sort { | a, b | a.to_s <=> b.to_s }
 =end
   end
-#end
 end
 

data/spec/message_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+$:.unshift File.expand_path('../../example', __FILE__)
+
+require 'asir'
+
+describe "ASIR::Message" do
+  attr_accessor :message, :data, :object
+
+  before(:each) do
+    self.data = { }
+    self.object = ASIR::Test::TestObject.new(self)
+    self.message = ASIR::Message.new(object, nil, nil, nil, nil)
+  end
+
+  it 'should return result.' do
+    message.receiver.should == object
+    message.selector.should == nil
+    message.arguments.should == nil
+    message.block.should == nil
+    message.selector = :return_argument
+    message.arguments = [ :this_value ]
+    result = message.invoke!
+    object.arg.should == :this_value
+    result.class.should == ASIR::Result
+    result.result.should == :this_value
+    result.message.should == message
+    result.exception.should == nil
+  end
+
+  it 'should capture exceptions.' do
+    cls = ::ASIR::Test::TestError
+    msg = "This message".freeze
+    message.selector = :raise_exception!
+    message.arguments = [ cls, msg ]
+    result = message.invoke!
+    object.cls.should == cls
+    object.msg.should == msg
+    result.class.should == ASIR::Result
+    result.result.should == nil
+    result.message.should == message
+    exc = result.exception
+    exc.class.should == ASIR::EncapsulatedException
+    exc.exception_class.should == cls.name
+    exc.exception_message.should == msg
+    exc.exception_backtrace.class.should == Array
+  end
+
+  it 'should capture Unforwardable exceptions.' do
+    cls = ::ASIR::Error::Unforwardable.unforwardable.first
+    cls.should_not == nil
+    msg = "This message".freeze
+    message.selector = :raise_exception!
+    message.arguments = [ cls, msg ]
+    result = message.invoke!
+    object.cls.should == cls
+    object.msg.should == msg
+    result.class.should == ASIR::Result
+    result.result.should == nil
+    result.message.should == message
+    exc = result.exception
+    exc.class.should == ASIR::EncapsulatedException
+    exc.exception_class.should == 'ASIR::Error::Unforwardable'
+    exc.exception_message.should == "#{cls.name} #{msg}"
+    exc.exception_backtrace.class.should == Array
+  end
+end
+

data/spec/performance_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'asir'
+
+describe "ASIR Performance" do
+  attr_accessor :transport, :data, :object
+  attr_accessor :n
+
+  before(:each) do
+    self.n = 1_000_000
+    self.data = { }
+    self.transport = ASIR::Transport::Local.new
+    self.object = ASIR::Test::TestObject.new(self)
+    object.class.asir.transport = transport
+  end
+
+  it 'Raw message time' do
+    run! do
+      object.return_argument :this_value
+    end
+    $raw_t = @t # FIXME!
+  end
+
+  it 'Message time using Transport::Local, Coder::Identity' do
+    run! do
+      object.asir.return_argument :this_value
+    end
+    that_t = $raw_t # FIXME!
+    this_t = @t
+    $stderr.puts "\nThis .vs. Raw: #{this_t[:ms_per_n] / that_t[:ms_per_n]} ms/msg / ms/msg"
+  end
+
+  def run! &blk
+    $stderr.puts "Warmup: #{desc} ..." if @verbose
+    (n / 100 + 100).times &blk
+    $stderr.puts "Warmup: DONE." if @verbose
+    elapsed do
+      n.times &blk
+    end
+  end
+
+  def elapsed
+    result = nil
+    @t = { }
+    $stderr.puts "Measuring: #{desc} ..." if @verbose
+    @t[:n] = n
+    @t[:t0] = Time.now
+    result = yield
+    @t[:t1] = Time.now
+    @t[:dt] = @t[:t1] - @t[:t0]
+    $stderr.puts "Measuring: DONE." if @verbose
+    $stderr.puts "\n#{desc}:"
+    $stderr.puts "  n       = #{@t[:n]}"
+    $stderr.puts "  elapsed = #{@t[:dt]} s"
+    $stderr.puts "  rate    = #{@t[:n_per_s]  = @t[:n] / @t[:dt]} n/s"
+    $stderr.puts "  time    = #{@t[:ms_per_n] = @t[:dt] / @t[:n] * 1000} ms/n"
+    result
+  end
+
+  def desc
+    @desc ||=
+      @example.metadata[:description_args] * " "
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -1,3 +1,37 @@
 require 'rubygems'
 require 'debug_helper'
 $: << File.expand_path('../../lib', __FILE__)
+
+require 'asir'
+
+module ASIR
+  module Test
+    class TestError < ::Exception; end
+    class TestObject
+      include ASIR::Client
+      attr_accessor :spec, :arg, :cls, :msg, :transport, :message
+      def initialize spec
+        @spec = spec
+      end
+
+      def get_data!
+        @transport = ASIR::Transport.current
+        @message = @transport && @transport.message
+      end
+
+      def return_argument arg
+        get_data!
+        @arg = arg
+        arg
+      end
+
+      def raise_exception! cls, msg
+        get_data!
+        @cls = cls
+        @msg = msg
+        raise cls, msg
+      end
+    end
+  end
+end
+

data/spec/thread_variable_spec.rb

@@ -0,0 +1,135 @@
+require 'asir/thread_variable'
+
+class ASIR::ThreadVariable::Test
+  include ASIR::ThreadVariable
+  cattr_accessor_thread :tv1
+  cattr_accessor_thread :tv2, :initialize => '1'
+  cattr_accessor_thread :tv3, :default => '2'
+  cattr_accessor_thread :tv4, :transform => '__val.to_s'
+  attr_accessor_thread  :iv1
+  attr_accessor :iv2
+end
+
+describe 'ASIR::ThreadVariable' do
+  def tc
+    @tc ||=
+      ASIR::ThreadVariable::Test
+  end
+  def ti
+    @ti ||=
+      tc.new
+  end
+
+  it 'cattr_accessor_thread handles concurrency' do
+    th1 = Thread.new {
+      tc.tv1.should == nil
+      tc.tv1 = 1
+      tc.tv1.should == 1
+      tc.with_attr! :tv1, 2 do
+        tc.tv1.should == 2
+      end
+      tc.tv1.should == 1
+      tc.clear_tv1.should == tc
+      tc.tv1.should == nil
+    }
+    th2 = Thread.new { 
+      tc.tv1.should == nil
+      tc.tv1 = 2
+      tc.tv1.should == 2
+      tc.clear_tv1.should == tc
+      tc.tv1.should == nil
+    }
+    th1.join
+    th2.join
+  end
+
+  it 'attr_accessor_thread handles concurrency' do
+    th1 = Thread.new do
+      begin
+        ti.iv1.should == nil
+        ti.iv1 = 1
+        ti.iv1.should == 1
+        ti.with_attr! :iv1, 2 do
+          ti.iv1.should == 2
+        end
+        ti.iv1.should == 1
+        ti.clear_iv1.should == ti
+        ti.iv1.should == nil
+      rescue Exception => exc
+        raise exc.class, "In th1: #{exc.message}", exc.backtrace
+      end
+    end
+    th2 = Thread.new do
+      begin
+        ti.iv1.should == nil
+        ti.iv1 = 2
+        ti.iv1.should == 2
+        ti.clear_iv1.should == ti
+        ti.iv1.should == nil
+      rescue Exception => exc
+        raise exc.class, "In th2: #{exc.message}", exc.backtrace
+      end
+    end
+    th1.join
+    th2.join
+  end
+
+  it 'cattr_accessor_thread basic options' do
+    tc.tv1.should == nil
+    tc.tv1 = 1
+    tc.tv1.should == 1
+    tc.clear_tv1
+    tc.tv1.should == nil
+  end
+
+  it 'cattr_accessor_thread :initialize option' do
+    tc.tv2.should == 1
+    tc.tv2 = 2
+    tc.tv2.should == 2
+    tc.clear_tv2
+    tc.tv2.should == 1
+  end
+
+  it 'cattr_accessor_thread :default option' do
+    tc.tv3.should == 2
+    tc.tv3 = 3
+    tc.tv3.should == 3
+    tc.clear_tv3
+    tc.tv3.should == 2
+  end
+
+  it 'cattr_accessor_thread :transform option' do
+    tc.tv4.should == ''
+    tc.tv4 = 101
+    tc.tv4.should == '101'
+    tc.tv4 = '102'
+    tc.tv4.should == '102'
+    tc.clear_tv4
+    tc.tv4.should == ''
+  end
+
+  it 'attr_accessor_thread :with_attr!' do
+    ti.iv1.should == nil
+    ti.with_attr! :iv1, :value do
+      ti.iv1.should == :value
+      ti.with_attr! :iv1, :value2 do
+        ti.iv1.should == :value2
+      end
+      ti.iv1.should == :value
+    end
+    ti.iv1.should == nil
+  end
+
+  it 'attr_accessor :with_attr!' do
+    ti.iv2.should == nil
+    ti.with_attr! :iv2, :value do
+      ti.iv2.should == :value
+      ti.with_attr! :iv2, :value2 do
+        ti.iv2.should == :value2
+      end
+      ti.iv2.should == :value
+    end
+    ti.iv2.should == nil
+  end
+end
+

data/spec/transport_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'asir'
+
+describe "ASIR::Transport" do
+  attr_accessor :transport, :data, :object
+
+  before(:each) do
+    self.data = { }
+    self.transport = ASIR::Transport::Local.new
+    self.object = ASIR::Test::TestObject.new(self)
+    object.class.asir.transport = transport
+    object.class.asir.transport.should == self.transport
+  end
+
+  it 'should return result.' do
+    result = object.asir.return_argument :this_value
+    object.arg.should == :this_value
+    result.should == :this_value
+  end
+
+  it 'should set ASIR::Transport only during processing.' do
+    ASIR::Transport.current.should == nil
+    object.asir.return_argument :this_value
+    ASIR::Transport.current.should == nil
+    object.transport.class.should == transport.class
+  end
+
+  it 'should not create clone of ASIR::Transport during processing.' do
+    object.asir.return_argument :this_value
+    object.transport.object_id.should == transport.object_id
+  end
+
+  it 'should set ASIR::Transport#message during processing.' do
+    transport.message.should == nil
+    object.asir.return_argument :this_value
+    transport.message.should == nil
+    object.transport.message.should == nil
+    object.message.class.should == ASIR::Message
+  end
+
+  it 'should handle on_result_exception callbacks' do
+    _transport, _result = nil, nil
+    p = lambda do | transport, result |
+      _transport = transport
+      _result = result
+    end
+    transport.on_result_exception = p
+
+    cls = ::ASIR::Test::TestError
+    msg = 'This Message'.freeze
+
+    object.asir.transport.on_result_exception.should == p
+
+    expect {
+      object.asir.raise_exception! cls, msg
+    }.to raise_error
+
+    object.msg.should == msg
+    object.message.class.should == ASIR::Message
+    object.transport.on_result_exception.class.should == Proc
+
+    result = object.message.result
+    result.class.should == ASIR::Result
+
+    exc = result.exception
+    exc.class.should == ASIR::EncapsulatedException
+    exc.exception_class.should == cls.name
+    exc.exception_message.should == msg
+    exc.exception_backtrace.class.should == Array
+
+    _transport.should == object.transport
+
+    _result.class.should == ASIR::Result
+    _result.object_id.should == result.object_id
+
+    _result.message.class.should == ASIR::Message
+    _result.message.object_id.should == result.message.object_id
+    _result.exception.should == exc
+  end
+end
+