dispatch 0.0.1pre

data/spec/job_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+if MACOSX_VERSION >= 10.6
+  describe "Dispatch::Job" do
+    
+    before :each do
+      @result = 0
+      @job = Dispatch::Job.new
+    end
+
+    describe :new do
+      it "should return a Job for tracking execution of passed blocks" do
+        @job.should be_kind_of Dispatch::Job
+      end
+
+      it "should use default queue" do
+        @job.add { Dispatch::Queue.current }
+        @job.value.to_s.should == Dispatch::Queue.concurrent.to_s
+      end
+
+      it "should take an optional queue" do
+        q = Dispatch::Queue.concurrent(:high)
+        job = Dispatch::Job.new(q) { Dispatch::Queue.current }
+        job.value.to_s.should == q.to_s
+      end
+    end
+    
+    describe :group do
+      it "should return an instance of Dispatch::Group" do
+        @job.group.should be_kind_of Dispatch::Group
+      end
+    end
+
+    describe :values do
+      it "should return an instance of Dispatch::Proxy" do
+        @job.values.should be_kind_of Dispatch::Proxy
+      end
+
+      it "has a __value__ that is Enumerable" do
+        @job.values.__value__.should be_kind_of Enumerable
+      end
+    end
+
+    describe :add do
+      it "should schedule a block for async execution" do
+        @value = 0
+        @job.add { sleep 0.01; @value = 42 }
+        @value.should == 0
+        @job.join
+        @value.should == 42
+      end
+    end
+    
+    describe :join do
+      it "should wait when called Synchronously" do
+        @value = 0
+        @job.add { sleep 0.01; @value = 42 }
+        @job.join
+        @value.should == 42
+      end
+
+      it "should invoke passed block Asynchronously" do
+        @value = 0
+        @rval = 0
+        @job.add { sleep 0.01; @value = 42 }
+        q = Dispatch::Queue.for(@value)
+        @job.join(q) { sleep 0.01; @rval = @value }
+        @job.join
+        @rval.should == 0
+        q.sync { }
+        @rval.should == 42
+      end
+    end
+
+    describe :value do
+      it "should return value when called Synchronously" do
+        @job.add { Math.sqrt(2**10) }
+        @job.value.should == 2**5
+      end
+
+      it "should invoke passed block Asynchronously with return value" do
+        @job.add { Math.sqrt(2**10) }
+        @value = 0
+        q = Dispatch::Queue.for(@value)
+        @job.value(q) {|v| @value = v}
+        @job.join
+        q.sync { }
+        @value.should == 2**5
+      end
+    end
+
+    describe :synchronize do
+      it "should return serialization Proxy for passed object" do
+        actee = {}
+        actor = @job.sync(actee)
+        actor.should be_kind_of Dispatch::Proxy
+        actor.__value__.should == actee
+      end
+
+    end
+
+  end
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+if MACOSX_VERSION >= 10.6
+  
+  class Delegate
+    def initialize(s); @s = s; end
+    def current_queue; Dispatch::Queue.current; end
+    def takes_block(&block); block.call; end
+    def get_number(); sleep 0.01; 42; end
+    def set_name(s); sleep 0.01; @s = s; end
+    def to_s; @s.to_s; end
+  end
+  
+  describe "Dispatch::Proxy" do
+    before :each do
+      @delegate_name = "my_delegate"
+      @delegate = Delegate.new(@delegate_name)
+      @proxy = Dispatch::Proxy.new(@delegate)
+    end
+    
+    describe :new do
+      it "returns a Dispatch::Proxy" do
+        @proxy.should be_kind_of Dispatch::Proxy
+        @proxy.should be_kind_of SimpleDelegator
+      end
+
+      it "takes an optional group and queue for callbacks" do
+        g = Dispatch::Group.new
+        q = Dispatch::Queue.concurrent(:high)
+        proxy = Dispatch::Proxy.new(@delegate, g, q)
+        proxy.__group__.should == g
+        proxy.__queue__.should == q
+      end
+
+      it "creates a default Group if none specified" do
+        @proxy.__group__.should be_kind_of Dispatch::Group
+      end
+
+      it "uses default queue if none specified" do
+        @proxy.__queue__.should == Dispatch::Queue.concurrent
+      end
+    end
+
+    describe :delegate do
+      it "should be returned by __getobj__" do
+        @proxy.__getobj__.should == @delegate
+      end
+
+      it "should be invoked for methods it defines" do
+        @proxy.to_s.should == @delegate_name
+      end
+    end
+
+    describe :method_missing do
+      it "runs methods on a private serial queue" do
+        q = @proxy.current_queue
+        q.label.should =~ /proxy/
+      end
+
+      it "should return Synchronously if block NOT given" do
+        retval = @proxy.get_number
+        retval.should == 42
+      end
+    
+      it "should otherwise return Asynchronous to block, if given" do
+        @value = 0
+        retval = @proxy.get_number { |v| @value = v }
+        @value.should == 0      
+        retval.should == nil
+        @proxy.__group__.wait
+        @value.should == 42      
+      end
+    end
+
+    describe :__value__ do
+      it "should complete work and return delegate" do
+        new_name = "nobody"
+        @proxy.set_name(new_name) { }
+        d = @proxy.__value__
+        d.should be_kind_of Delegate
+        d.to_s.should == new_name
+      end
+    end
+    
+    describe "state" do
+      it "should persist for collection objects" do
+        actor = Dispatch::Proxy.new([])
+        actor.size.should == 0
+        actor << :foo
+        actor.size.should == 1
+        actor[42] = :foo
+        actor.size.should == 43        
+        actor.should be_kind_of Dispatch::Proxy
+      end
+      
+      it "should NOT persist under assignment" do
+        actor = Dispatch::Proxy.new(0)
+        actor.should be_kind_of Dispatch::Proxy
+        actor += 1
+        actor.should_not be_kind_of Dispatch::Proxy
+      end
+    end
+
+  end  
+end

data/spec/queue_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+if MACOSX_VERSION >= 10.6
+  
+  describe "Dispatch::Queue" do
+    before :each do
+      @my_object = "Hello, World!"
+      @q = Dispatch::Queue.for(@my_object)
+    end
+
+    describe :labelize do
+      it "should return a unique label for any object" do
+        s1 = Dispatch::Queue.labelize @my_object
+        s2 = Dispatch::Queue.labelize @my_object
+        s1.should_not == s2
+      end
+    end
+
+    describe :for do
+      it "should return a dispatch queue" do
+        @q.should be_kind_of Dispatch::Queue
+      end
+
+      it "should return a unique queue for each object" do
+        q = Dispatch::Queue.for(@my_object)
+        @q.should_not == q
+      end
+
+      it "should return a unique label for each queue" do
+        q = Dispatch::Queue.for(@my_object)
+        @q.to_s.should_not == q.to_s
+      end
+    end
+
+    describe :join do
+      it "should wait until pending blocks execute " do
+        @n = 0
+        @q.async {@n = 42}
+        @n.should == 0
+        @q.join
+        @n.should == 42
+      end
+    end
+  end
+end

data/spec/source_spec.rb

@@ -0,0 +1,190 @@
+require "spec_helper"
+
+if MACOSX_VERSION >= 10.6
+
+  describe "Dispatch::Source" do
+    before :each do
+      @q = Dispatch::Queue.new('org.macruby.gcd_spec.prelude')
+      @src = nil
+    end
+
+    after :each do
+      @src.cancel! if not @src.nil? and not @src.cancelled?
+      @q.sync { }
+    end
+
+
+    describe :event2num do
+      it "converts PROC symbol to int" do
+        Dispatch::Source.event2num(:signal).should == Dispatch::Source::PROC_SIGNAL
+      end
+
+      it "converts VNODE symbol to int" do
+        Dispatch::Source.event2num(:rename).should == Dispatch::Source::VNODE_RENAME
+      end
+    end
+    
+    describe :data2events do
+      it "converts PROC bitfields to symbols" do
+        mask = Dispatch::Source::PROC_EXIT | Dispatch::Source::PROC_SIGNAL 
+        events = Dispatch::Source.data2events(mask)
+        events.include?(:signal).should == true
+        events.include?(:fork).should == false
+      end
+
+      it "converts VNODE bitfields to symbols" do
+        mask = Dispatch::Source::VNODE_DELETE | Dispatch::Source::VNODE_WRITE
+        events = Dispatch::Source.data2events(mask)
+        events.include?(:delete).should == true
+        events.include?(:rename).should == false
+      end
+    end
+    
+    describe "add" do
+      it "fires with data on summed inputs" do
+        @count = 0
+        @src = Dispatch::Source.add(@q) {|s| @count += s.data}
+        @src << 20
+        @src << 22
+        @q.sync {}
+        @count.should == 42
+      end
+    end    
+
+    describe "or" do
+      it "fires with data on ORed inputs" do
+        @count = 0
+        @src = Dispatch::Source.or(@q) {|s| @count += s.data}
+        @src << 0b101_000
+        @src << 0b000_010
+        @q.sync {}
+        @count.should == 42
+      end
+    end    
+
+    describe "PROC" do
+      before :each do
+        @signal = Signal.list["USR1"]
+      end
+
+      describe "process" do
+        
+        it "fires with data on process event(s)" do
+          @event = 0
+          @events = []
+          @src = Dispatch::Source.process($$, %w(exit fork exec signal), @q) do |s|
+             @event += s.data
+             @events += Dispatch::Source.data2events(s.data)
+          end
+          Signal.trap(@signal, "IGNORE")
+          Process.kill(@signal, $$)
+          Signal.trap(@signal, "DEFAULT")
+          @q.sync {}
+          @events.include?(:signal).should == true
+        end
+      
+        it "can use bitfields as well as arrays" do
+          mask = Dispatch::Source::PROC_EXIT | Dispatch::Source::PROC_SIGNAL 
+          @event = 0
+          @src = Dispatch::Source.process($$, mask, @q) { |s| @event |= s.data }
+          Signal.trap(@signal, "IGNORE")
+          Process.kill(@signal, $$)
+          Signal.trap(@signal, "DEFAULT")
+          @q.sync {}
+          @event.should == Dispatch::Source.event2num(:signal)
+        end
+      end
+
+      describe "signal" do
+        it "fires with data on signal count" do
+          @count = 0
+          @src = Dispatch::Source.signal(@signal, @q) {|s| @count += s.data}
+          Signal.trap(@signal, "IGNORE")
+          Process.kill(@signal, $$)
+          Process.kill(@signal, $$)
+          Signal.trap(@signal, "DEFAULT")
+          @q.sync {}
+          @count.should == 2
+          @src.cancel!
+        end
+      end  
+    end  
+
+    describe "VNODE" do
+      before :each do
+        @msg = "#{$$}-#{Time.now.to_s.gsub(' ','_')}"
+        @filename = tmp("gcd_spec_source-#{@msg}")
+        @file = nil
+        @src = nil
+      end
+
+      after :each do
+        @src.cancel! if not @src.nil? and not @src.cancelled?
+        @q.sync { }
+        @file.close if not @file.closed?
+        File.delete(@filename)
+      end
+
+      describe "read" do
+        it "fires with data on readable bytes" do
+          File.open(@filename, "w") {|f| f.print @msg}
+          @file = File.open(@filename, "r")
+          @result = ""
+          @src = Dispatch::Source.read(@file, @q) {|s| @result<<@file.read(s.data)}
+          while (@result.size < @msg.size) do; end
+          @q.sync { }
+          @result.should == @msg
+        end
+      end    
+
+      describe "write" do
+        it "fires with data on writable bytes" do
+          @file = File.open(@filename, "w")
+          @message = @msg
+          @src = Dispatch::Source.write(@file, @q) do |s|
+            if @message.size > 0 then
+              char = @message[0..0]
+              @file.write(char)
+              @message = @message[1..-1]
+            end
+          end
+          while (@message.size > 0) do; end
+          result = File.read(@filename)
+          @result.should == @msg
+        end
+      end
+      
+      describe "file" do
+        it "fires with data on file events" do
+          write_flag = Dispatch::Source.event2num(:write)
+          @file = File.open(@filename, "w")
+          @fired = false
+          @mask = 0
+          events = %w(delete write extend attrib link rename revoke)
+          @src = Dispatch::Source.file(@file, events, @q) do |s|
+              @mask |= s.data
+              @fired = true
+          end
+          @file.write(@msg)
+          @file.flush
+          @q.sync { }
+          @fired.should == true
+          (@mask & write_flag).should == write_flag
+        end
+      end          
+    end
+
+    describe "periodic" do
+      it "fires with data on how often the timer has fired" do
+        @count = -1
+        repeats = 2
+        @periodic = 0.02
+        @src = Dispatch::Source.periodic(@periodic, @q) {|s| @count += s.data}
+        sleep repeats*@periodic
+        @q.sync { }
+        @count.should == repeats
+      end
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), "../lib/dispatch")
+
+framework 'Cocoa'
+
+SPEC_ROOT = File.dirname(__FILE__)
+FIXTURES = File.join(SPEC_ROOT, "fixtures")
+
+class FixtureCompiler
+  def self.require!(fixture)
+    new(fixture).require!
+  end
+  
+  FRAMEWORKS = %w{ Foundation }
+  ARCHS      = %w{ i386 x86_64 }
+  OPTIONS    = %w{ -g -dynamiclib -fobjc-gc -Wl,-undefined,dynamic_lookup }
+  GCC        = "/usr/bin/gcc"
+  
+  attr_reader :gcc, :frameworks, :archs, :options
+  attr_reader :fixture, :bundle, :bridge_support
+  
+  def initialize(fixture)
+    @fixture = File.join(FIXTURES, "#{fixture}.m")
+    @bundle = File.join("/tmp", "#{fixture}.bundle")
+    @bridge_support = File.join(FIXTURES, "#{fixture}.bridgesupport")
+    
+    @gcc, @frameworks, @archs, @options = [GCC, FRAMEWORKS, ARCHS, OPTIONS].map { |x| x.dup }
+  end
+  
+  def require!
+    compile!
+    load!
+  end
+  
+  private
+  
+  def needs_update?
+    !File.exist?(bundle) or File.mtime(fixture) > File.mtime(bundle)
+  end
+  
+  def compile!
+    if needs_update?
+      puts "[!] Compiling fixture `#{fixture}'"
+      
+      a = archs.map { |a| "-arch #{a}" }.join(' ')
+      o = options.join(' ')
+      f = frameworks.map { |f| "-framework #{f}" }.join(' ')
+      
+      `#{gcc} #{fixture} -o #{bundle} #{f} #{o} #{a}`
+    end
+  end
+  
+  def load!
+    require bundle[0..-8]
+    if File.exist? bridge_support
+      load_bridge_support_file bridge_support
+    end
+  end
+end
+
+MACOSX_VERSION = `sw_vers -productVersion`.to_f