multiprocessing 0.0.1 → 0.0.2

data/spec/multiprocessing/semaphore_spec.rb

@@ -1,56 +1,159 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
 require 'timeout'
 
-describe MultiProcessing::Semaphore, "initialized with 1" do
+describe MultiProcessing::Semaphore, "initialized with 2" do
 
   before do
-    @semaphore = MultiProcessing::Semaphore.new 1
+    @semaphore = MultiProcessing::Semaphore.new 2
   end
 
-  it "#P return itself" do
-    @semaphore.lock.should === @semaphore
-  end
+  describe "#P" do
 
-  it "#V returns itself" do
-    @semaphore.lock
-    @semaphore.unlock.should === @semaphore
-  end
+    context "when resource is remaining" do
+      it "return itself" do
+        @semaphore.lock.should === @semaphore
+      end
+    end
+
+    context "when resource is not remaining" do
 
+      before do
+        fork do
+          @semaphore.P
+          @semaphore.P
+          sleep 0.03
+        end
+        sleep 0.01
+      end
+
+      it "blocks" do
+        proc{ timeout(0.01){ @semaphore.P } }.should raise_error Timeout::Error
+      end
+
+    end
 
-  it "#count returns number of remaining resource" do
-    @semaphore.count.should == 1
-    @semaphore.P
-    @semaphore.count.should == 0
-    @semaphore.V
-    @semaphore.V
-    @semaphore.count.should == 2
   end
 
-  it "#try_P returns true if succeed, and P correctly" do
-    @semaphore.try_P.should be_true
-    @semaphore.count.should == 0
+  describe "#V" do
+
+    it "#V returns itself" do
+      @semaphore.lock
+      @semaphore.unlock.should === @semaphore
+    end
+
+    context "when a thread is waiting" do
+
+      before do
+        @pid = fork do
+          @semaphore.P
+          @semaphore.P
+          @semaphore.P # blocks
+        end
+        @detached_thread = Process.detach(@pid)
+        sleep 0.01
+      end
+
+      it "makes the other thread blocked restart" do
+        @semaphore.V
+        @detached_thread.join(1).should_not be_nil
+      end
+
+      after do
+        begin
+          Process.kill :TERM, @pid
+        rescue Errno::ESRCH
+        end
+      end
+
+    end
+
   end
 
-  it "#try_P returns false if failed" do
-    process = MultiProcessing::Process.new do
-      @semaphore.P
-      sleep 0.2
+  describe "#count" do
+
+    context "resource locked in same thread" do
+      it "returns number of remaining resource" do
+        @semaphore.count.should == 2
+        @semaphore.P
+        @semaphore.count.should == 1
+        @semaphore.P
+        @semaphore.count.should == 0
+        @semaphore.V
+        @semaphore.count.should == 1
+      end
+    end
+
+    context "resource locked in another process" do
+
+      before do
+        @pid = fork do
+          sleep 0.02
+          @semaphore.P
+          sleep 0.02
+          @semaphore.P
+          sleep 0.02
+          @semaphore.V
+        end
+        sleep 0.01
+      end
+
+      it "returns number of remaining resource" do
+        @semaphore.count.should == 2
+        sleep 0.02
+        @semaphore.count.should == 1
+        sleep 0.02
+        @semaphore.count.should == 0
+        sleep 0.02
+        @semaphore.count.should == 1
+      end
+
+      after do
+        begin
+          Process.kill :TERM, @pid
+        rescue Errno::ESRCH
+        end
+      end
+
     end
-    sleep 0.1
-    @semaphore.try_P.should be_false
+
   end
 
-  it "#synchronize can lock resource and yield and free" do
-    tmp = nil
-    @semaphore.synchronize do
-      @semaphore.count.should == 0
-      tmp = true
+  describe "#try_P" do
+
+    context "when remaining resource" do
+      it "returns true" do
+        @semaphore.try_P.should be_true
+        @semaphore.count.should == 1
+      end
+    end
+
+    context "when not remaining resource" do
+      it "returns false" do
+        pid = fork do
+          @semaphore.P
+          @semaphore.P
+        end
+        sleep 0.03
+        @semaphore.try_P.should be_false
+        @semaphore.count.should == 0
+      end
     end
-    tmp.should be_true
-    @semaphore.count.should == 1
   end
-  
 
+  describe "#synchronize" do
+    it "locks resource and yields and unlocks" do
+      tmp = nil
+      @semaphore.count.should == 2
+      @semaphore.synchronize do
+        @semaphore.count.should == 1
+        tmp = true
+      end
+      tmp.should be_true
+      @semaphore.count.should == 2
+    end
+  end
 
 end
 
+
+

data/spec/spec_helper.rb

@@ -1,3 +1,17 @@
+begin
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter "spec/"
+  end
+
+  pid = Process.pid
+  SimpleCov.at_exit do
+    SimpleCov.result.format! if Process.pid == pid
+  end
+rescue LoadError
+end
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
@@ -8,5 +22,5 @@ require 'multiprocessing'
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  
+
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multiprocessing
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - clicube
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-13 00:00:00.000000000 Z
+date: 2013-07-14 00:00:00.000000000 Z
 dependencies: []
 description: Classes for inter-process synchronization/communication like thread library
   in ruby standard library
@@ -20,8 +19,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .yardopts
 - Gemfile
 - LICENSE.txt
+- README.ja.md
 - README.md
 - Rakefile
 - lib/multiprocessing.rb
@@ -29,44 +30,42 @@ files:
 - lib/multiprocessing/externalobject.rb
 - lib/multiprocessing/mutex.rb
 - lib/multiprocessing/namedpipe.rb
-- lib/multiprocessing/process.rb
 - lib/multiprocessing/processerror.rb
 - lib/multiprocessing/queue.rb
 - lib/multiprocessing/semaphore.rb
 - lib/multiprocessing/version.rb
 - multiprocessing.gemspec
+- spec/multiprocessing/conditionvariable_spec.rb
 - spec/multiprocessing/mutex_spec.rb
-- spec/multiprocessing/process_spec.rb
 - spec/multiprocessing/queue_spec.rb
 - spec/multiprocessing/semaphore_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/clicube/multiprocessing
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Inter-process synchronization/communication
 test_files:
+- spec/multiprocessing/conditionvariable_spec.rb
 - spec/multiprocessing/mutex_spec.rb
-- spec/multiprocessing/process_spec.rb
 - spec/multiprocessing/queue_spec.rb
 - spec/multiprocessing/semaphore_spec.rb
 - spec/spec_helper.rb

data/lib/multiprocessing/process.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/processerror')
-
-module MultiProcessing
-  class Process
-
-    attr_reader :pid
-
-    def initialize *args
-      raise ProcessError.new "mulst be called with a block" unless block_given?
-      @pid = fork do
-        yield *args
-        exit
-      end
-    end
-
-    def value
-      th = ::Process.detach(@pid)
-      th.value
-    end
-
-    def join timeout=nil
-      th = ::Process.detach(@pid)
-      th.join timeout
-    end
-
-    def kill signal
-      ::Process.kill signal, @pid
-    end
-
-  end
-end
-
-if $0 == __FILE__
-  include MultiProcessing
-
-  p = MultiProcessing::Process.new("nyan") do |str|
-    puts str
-    sleep 1
-  end
-  p p
-  p.join
-end
-

data/spec/multiprocessing/process_spec.rb

@@ -1,51 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
-
-describe MultiProcessing::Process do
-
-  it "can be created with block" do
-    MultiProcessing::Process.new{:nop}.should be_instance_of MultiProcessing::Process
-  end
-
-  it "cannot be created without block" do
-    proc{ MultiProcessing::Process.new }.should raise_error MultiProcessing::ProcessError
-  end
-
-  it "returns pid" do
-    MultiProcessing::Process.new{ :nop }.pid.should be_instance_of Fixnum
-  end
-
-  it "joins process" do
-    p = MultiProcessing::Process.new { :nop }
-    p.join.should_not be_nil
-  end
-
-  it "joins process with timeout" do
-    p = MultiProcessing::Process.new { :nop }
-    p.join(1).should_not be_nil
-    p = MultiProcessing::Process.new { sleep 1 }
-    p.join(0).should be_nil
-  end
-
-  it "returns value" do
-    p = MultiProcessing::Process.new { :nop }
-    p.value.should be_instance_of ::Process::Status
-    p = MultiProcessing::Process.new { :nop }
-    p.value.success?.should be_true
-    p = MultiProcessing::Process.new { exit 1 }
-    p.value.success?.should be_false
-  end
-
-  it "returns nil when process does not exist" do
-    p = MultiProcessing::Process.new { :nop }
-    p.join
-    p.value.should be_nil
-  end
-
-  it "can be kill" do
-    p = MultiProcessing::Process.new { sleep 1 }
-    p.kill :TERM
-    p.join(0).should be_nil
-  end
-
-end
-