rcapture 1.0.4

data/test/acceptance/acc_modify_arguments.rb

@@ -0,0 +1,50 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'rcapture'
+include RCapture
+
+class AcceptanceModifyArguments < Test::Unit::TestCase
+    
+  def test_pre
+    x = Array.new
+    x.extend(Interceptable)
+    x.capture_pre :methods => :<< do |ci|
+      ci.a[0] += 1
+    end
+   
+    x << 1 << 2
+    assert_equal([2, 3], x)
+  end
+  
+  def test_pre_return
+    x = Array.new
+    x.extend(Interceptable)
+    x.capture_pre :methods => :<< do |ci|
+      ci.p = ci.s.length < 2
+      ci.r = ci.s
+    end
+    
+    x << 1 << 2 << 3 << 4
+    assert_equal([1, 2], x)
+    
+  end
+  
+  def test_post_return
+    x = Array.new
+    x.extend(Interceptable)
+    x.capture_post :methods => :length do |ci|
+      ci.r -= 1
+    end
+    
+    x << 1 << 2
+    assert_equal(1, x.length)
+    x << 1 << 2
+    assert_equal(3, x.length)
+    
+  end
+end

data/test/acceptance/acc_new_with_block.rb

@@ -0,0 +1,52 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'rcapture'
+include RCapture
+
+class X
+  include Interceptable
+  
+  def initialize(name)
+    @name = name
+  end
+  
+  def say_hello
+    puts "Hello, #{@name}!"
+  end
+end
+
+class Y < X
+  def initialize
+    super("y")
+  end
+end
+
+class AcceptanceNewWithBlock < Test::Unit::TestCase
+  
+  def test_new_with_block
+    
+    X.capture_post :class_methods => :new do |ci|
+      ci.b.call(ci.r) if ci.b
+    end
+    
+    x = X.new("as")
+    assert_instance_of(X, x)
+    
+    X.new("christoph") do |x|
+      assert_instance_of(X, x)
+      x.say_hello
+    end
+    
+    Y.new do |y|
+      assert_instance_of(Y, y)
+      y.say_hello
+    end
+    
+  end
+    
+end

data/test/acceptance/acc_policies.rb

@@ -0,0 +1,37 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'rcapture'
+include RCapture
+
+class Fixnum
+  include Interceptable
+end
+
+class AcceptancePolicies < Test::Unit::TestCase
+    
+  def test_clamping_policy
+    
+    min = 0
+    max = 1
+    clamp_policy = Proc.new do |ci|
+      ci.a.collect! do |v|
+        if v.instance_of?(Fixnum)
+          (v < min) ? min : ((v > max) ?  max : v)
+        else
+          v
+        end
+      end
+    end
+    
+    Fixnum.capture_pre :methods => [:+,:-], &clamp_policy
+    
+    assert_equal(1, 0+1)
+    assert_equal(1, 0+4)
+    assert_equal(2, 0+4+2-30+3)
+  end
+end

data/test/benchmark/benchmark_capture.rb

@@ -0,0 +1,60 @@
+  require 'test/unit'
+  require 'test/unit/testee'
+  require 'benchmark'
+  require 'rcapture'
+
+  class Fixnum
+    include RCapture::Interceptable
+  end
+
+  class BenchmarkCapture < Test::Unit::TestCase
+    
+    def test_benchmark_native
+      n = 100000
+      puts "Benchmarking addition"
+      Benchmark.bm do |x|
+        x.report { n.times do; 1+1; end }
+        Fixnum.capture :methods => :+ do
+        end
+        x.report { n.times do; 1+1; end }
+      end
+      
+      # On my machine Intel Q6600, 2.4GHz
+      #
+      # Ruby 1.8.6
+      # user     system      total        real
+      # 0.015000   0.000000   0.015000 (  0.027000)
+      # 1.610000   0.000000   1.610000 (  1.629000)
+      # overhead is roughly 0,00001602 secs per invocation
+      #
+      # Ruby 1.9.1
+      # user     system      total        real
+      # 0.000000   0.000000   0.000000 (  0.009765)
+      # 0.359000   0.000000   0.359000 (  0.356446)
+      # overhead is roughly 0,0000034 secs per invocation
+    end
+    
+    def test_benchmark_construct
+      n = 100000
+      puts "Benchmarking construction of new objects"
+      Benchmark.bm do |x|
+        x.report { n.times do; Testee.new; end }
+        Testee.capture :class_methods => :new do
+        end
+        x.report { n.times do; Testee.new; end }
+      end
+      
+      # On my machine Intel Q6600, 2.4GHz
+      #
+      # user     system      total        real
+      # 0.188000   0.000000   0.188000 (  0.208000)
+      # 1.812000   0.000000   1.812000 (  1.836000)
+      # overhead is roughly 0,00001628 secs per invocation
+      #
+      # Ruby 1.9.1
+      # user     system      total        real
+      # 0.047000   0.000000   0.047000 (  0.051757)
+      # 0.422000   0.000000   0.422000 (  0.408203)
+      # overhead is roughly 0,00000357 secs per invocation
+    end
+  end

data/test/unit/test_capture_status.rb

@@ -0,0 +1,66 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'thread'
+require 'rcapture'
+include RCapture
+
+class TestCaptureStatus < Test::Unit::TestCase
+    
+  def test_status
+    s = CaptureStatus.new(true)
+    assert(s.on?)
+    s.set(true); assert(s.on?)
+    s.set(true); assert(s.on?)
+    s.set(false); assert(s.off?)
+    s.set(false); assert(s.off?)
+    s.restore; assert(s.off?)
+    s.restore; assert(s.on?)
+    s.restore; assert(s.on?)
+    s.restore; assert(s.on?)
+    s.restore; assert(s.on?)
+  end
+  
+  def calc(status)
+    return true if status.on?
+    return false if status.off?
+  end
+  
+  def test_scope
+    s = CaptureStatus.new(true)
+    ret = s.use(false) do
+      self.calc(s)
+    end
+    assert(!ret)
+    assert(self.calc(s))
+    ret = s.use(true) do
+      self.calc(s)
+    end
+    assert(ret)
+  end
+  
+  def test_thread_local
+    a_cs = nil
+    a_cs2 = nil
+    b_cs = nil
+    
+    a = Thread.new do 
+      a_cs = CaptureStatus.current
+      a_cs2 = CaptureStatus.current
+    end
+    
+    b = Thread.new do 
+      b_cs = CaptureStatus.current
+    end
+    
+    a.join
+    b.join
+    
+    assert_same(a_cs, a_cs2)
+    assert_not_same(a_cs, b_cs)
+  end
+end

data/test/unit/test_captured_info.rb

@@ -0,0 +1,93 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'rcapture'
+include RCapture
+
+class TestCapturedInfo < Test::Unit::TestCase
+    
+  def test_info
+    ci = CapturedInfo.new
+    ci.fill([1,2], self, :test_info)
+    
+    assert_equal([1,2], ci.args)
+    assert_same(self, ci.sender)
+    assert_same(:test_info, ci.method)
+    assert_equal(nil, ci.block)
+    assert_equal(nil, ci.return)
+    assert(ci.predicate)    
+  end
+  
+  def test_aliases
+    ci = CapturedInfo.new
+    ci.fill([1,2], self, :test_info)
+    
+    assert_equal([1,2], ci.a)
+    assert_same(self, ci.s)
+    assert_same(:test_info, ci.m)
+    assert_equal(nil, ci.b)
+    assert_equal(nil, ci.r)
+    assert(ci.p)    
+    
+    ci.r = 4
+    ci.p = false
+    
+    assert_equal(4, ci.r)
+    assert(!ci.p)
+  end
+  
+  def test_pre_capture
+    a = []
+    a.extend(Interceptable)
+    a.capture_pre :methods => :<< do |cs|
+      assert_equal([1], cs.a)
+      assert_same(a, cs.s)
+      assert_same(:<<, cs.m)
+      assert_nil(cs.b)
+      assert(cs.p)
+      assert_nil(cs.r)
+      cs.r = :ok
+      cs.p = false
+    end
+    
+    assert_equal(:ok, a << 1)
+    assert_equal([], a)
+    
+    proc = Proc.new do |v|
+    end
+    
+    a.capture_pre :methods => :each do |cs|
+      assert_same(proc, cs.b)
+    end
+    a.each &proc
+  end
+  
+  def test_post_capture
+    a = []
+    a.extend(Interceptable)
+    a.capture_post :methods => :<< do |cs|
+      assert_equal([1], cs.a)
+      assert_same(a, cs.s)
+      assert_same(:<<, cs.m)
+      assert_same(a, cs.r)
+      assert_nil(cs.b)
+      assert(cs.p)
+      cs.r = :ok
+    end
+    
+    assert_equal(:ok, a << 1)
+    assert_equal([1], a)
+    
+    proc = Proc.new do |v|
+    end
+    
+    a.capture_pre :methods => :each do |cs|
+      assert_same(proc, cs.b)
+    end
+    a.each &proc    
+  end
+end

data/test/unit/test_method_with_blocks.rb

@@ -0,0 +1,32 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'rcapture'
+
+class Array
+  include RCapture::Interceptable
+end
+
+class TestMethodWithBlocks < Test::Unit::TestCase
+  
+  def test_array
+    count = 0
+    Array.capture :methods => :each do
+      count += 1
+    end
+    
+    x = []
+    x << 1 << 2
+    sum = 0
+    x.each do |v|
+      sum += v
+    end
+    
+    assert_equal(1, count)
+    assert_equal(3, sum)
+  end
+end

data/test/unit/test_modify_arguments.rb

@@ -0,0 +1,99 @@
+#
+# (c) Christoph Heindl, 2010
+# http://cheind.wordpress.com
+#
+
+require 'test/unit'
+
+require 'rcapture'
+
+class TestModifyArguments < Test::Unit::TestCase
+  
+  def test_capture_pre
+    x = []
+    x.extend(RCapture::Interceptable)
+    
+    inc = Proc.new do |ci|
+      ci.a[0] += 1
+    end
+    
+    dec = Proc.new do |ci|
+      ci.a[0] -= 1
+    end
+    
+    mul = Proc.new do |ci|
+      ci.a[0] *= 2
+    end
+    
+    x.capture_pre :methods => :<<, &inc
+    x.capture_pre :methods => :<<, &mul
+    x.capture_pre :methods => :<<, &inc
+    x.capture_pre :methods => :<<, &dec
+    x.capture_pre :methods => :<<, &dec
+    
+    x << 2 << 4
+    assert_equal([3,7], x) 
+  end
+  
+  def test_capture_post
+    x = []
+    x.extend(RCapture::Interceptable)
+    
+    inc = Proc.new do |ci|
+      ci.r += 1
+    end
+    
+    dec = Proc.new do |ci|
+      ci.r -= 1
+    end
+    
+    mul = Proc.new do |ci|
+      ci.r *= 2
+    end
+    
+    x.capture_post :methods => :[], &inc
+    x.capture_post :methods => :[], &mul
+    x.capture_post :methods => :[], &inc
+    x.capture_post :methods => :[], &dec
+    x.capture_post :methods => :[], &dec
+    
+    x << 1 << 4
+    
+    assert_equal(3, x[0])
+    assert_equal(9, x[1])
+  end
+  
+  def test_capture_pre_post
+    x = []
+    x.extend(RCapture::Interceptable)
+    
+    inc = Proc.new do |ci|
+      ci.a[0] += 1
+    end
+    
+    mul = Proc.new do |ci|
+      ci.r *= 2
+    end
+    
+    x.capture_pre :methods => :<<, &inc
+    x.capture_post :methods => :[], &mul
+    
+    x << 2 << 7
+    assert_equal(6, x[0])
+    assert_equal(16, x[1])
+  end
+  
+  def test_capture_pre_return
+    x = []
+    x.extend(RCapture::Interceptable)
+    
+    filter = Proc.new do |ci|
+      ci.r = ci.s
+      ci.p = ci.a[0] % 2 == 0
+    end
+    
+    x.capture_pre :methods => :<<, &filter
+    x << 2 << 8 << 7 << 6 << 5
+    assert_equal([2,8,6], x)
+  end
+end