win32-mutex 0.4.1 → 0.4.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b251ba3b27d23aec7948bca16d023ae9582ac4c
+  data.tar.gz: 12e840ea6969ea066381de5647a73cd69aabf413
+SHA512:
+  metadata.gz: ad2a8b1b7b60fb50d0a58bda465c61b3b02f281ff2d2dbcc540dbcf30511846f8a384a3428b79ecdfcaed25f5fcca55ec3467627075b21c790d657baaebcfff7
+  data.tar.gz: 55123e27d398edfebc923f632d69060beb496f2012989d5d97143a65a855f2ed067e318977324df194b29fbb1779bd190348e00b9d54f6f909e524889e5a8652

data/CHANGES

@@ -1,53 +1,58 @@
-== 0.4.1 - 10-Apr-2013
-* Fixed HANDLE type in underlying FFI code. This affects 64 bit versions
-  of Ruby.
-
-== 0.4.0 - 10-Jul-2012
-* Converted to FFI.
-* Now requires Ruby 1.9 or later.
-* Removed the Error class. If a Windows function fails it raises the
-  appropriate SystemCallError (Errno::).
-
-== 0.3.2 - 18-Mar-2011
-* Updates to the Rakefile and gemspec.
-* One test file change for Ruby 1.9.
-
-== 0.3.1 - 8-Aug-2009
-* Changed license to Artistic 2.0.
-* Updated the gemspec, including addition of license and description update.
-* Renamed the test and example files.
-* Added test-unit, win32-process and win32-mmap as development dependencies.
-
-== 0.3.0 - 4-May-2007
-* Now pure Ruby.
-* Both the Mutex.new and Mutex.open methods now accept a block, and
-  automatically close the associated handle at the end of the block.
-* The Mutex.new method now accepts an optional third argument that controls
-  whether the mutex object can be inherited by other processes.
-* Added a gemspec.
-* Added a Rakefile, including tasks for installation and testing.
-* Removed the doc/mutext.txt file. The documentation is now inlined via RDoc.
-  There is also some documentation in the README file.
-* The mutex_test.rb script was updated and bugs were fixed.
-* Now requires the windows-pr package.
-
-== 0.2.2 - 29-May-2005
-* Now Unicode friendly.
-* Removed the mutex.rd file.  The mutex.txt file is now rdoc friendly.
-* Added some tests and tweaked the test setup.
-
-== 0.2.1 - 1-Mar-2005
-* Moved the 'examples' directory to the toplevel directory.
-* Made the CHANGES and README files rdoc friendly.
-
-== 0.2.0 - 18-Jul-2004
-* Updated to use the newer allocation framework.  This means that, as of this
-  release, this package requires Ruby 1.8.0 or later.
-* Fixed a minor bug in the initialization function where an expected error
-  might not be raised.
-* Added tests and documentation for Mutex.open().  This was in the last
-  version, but I forgot to document or test it.
-* Moved the test.rb script to doc/examples
-
-== 0.1.0 - 3-May-2004
-* Initial release
+== 0.4.2 - 21-Oct-2013
+* Fixed INVALID_HANDLE_VALUE constant for 64-bit Ruby.
+* Added Rake as a development dependency.
+* Updated gem:create task for Rubygems 2.
+
+== 0.4.1 - 10-Apr-2013
+* Fixed HANDLE type in underlying FFI code. This affects 64 bit versions
+  of Ruby.
+
+== 0.4.0 - 10-Jul-2012
+* Converted to FFI.
+* Now requires Ruby 1.9 or later.
+* Removed the Error class. If a Windows function fails it raises the
+  appropriate SystemCallError (Errno::).
+
+== 0.3.2 - 18-Mar-2011
+* Updates to the Rakefile and gemspec.
+* One test file change for Ruby 1.9.
+
+== 0.3.1 - 8-Aug-2009
+* Changed license to Artistic 2.0.
+* Updated the gemspec, including addition of license and description update.
+* Renamed the test and example files.
+* Added test-unit, win32-process and win32-mmap as development dependencies.
+
+== 0.3.0 - 4-May-2007
+* Now pure Ruby.
+* Both the Mutex.new and Mutex.open methods now accept a block, and
+  automatically close the associated handle at the end of the block.
+* The Mutex.new method now accepts an optional third argument that controls
+  whether the mutex object can be inherited by other processes.
+* Added a gemspec.
+* Added a Rakefile, including tasks for installation and testing.
+* Removed the doc/mutext.txt file. The documentation is now inlined via RDoc.
+  There is also some documentation in the README file.
+* The mutex_test.rb script was updated and bugs were fixed.
+* Now requires the windows-pr package.
+
+== 0.2.2 - 29-May-2005
+* Now Unicode friendly.
+* Removed the mutex.rd file.  The mutex.txt file is now rdoc friendly.
+* Added some tests and tweaked the test setup.
+
+== 0.2.1 - 1-Mar-2005
+* Moved the 'examples' directory to the toplevel directory.
+* Made the CHANGES and README files rdoc friendly.
+
+== 0.2.0 - 18-Jul-2004
+* Updated to use the newer allocation framework.  This means that, as of this
+  release, this package requires Ruby 1.8.0 or later.
+* Fixed a minor bug in the initialization function where an expected error
+  might not be raised.
+* Added tests and documentation for Mutex.open().  This was in the last
+  version, but I forgot to document or test it.
+* Moved the test.rb script to doc/examples
+
+== 0.1.0 - 3-May-2004
+* Initial release

data/MANIFEST

@@ -1,8 +1,8 @@
-* CHANGES
-* INSTALL
-* MANIFEST
-* Rakefile
-* win32-mutex.gemspec
-* examples/mutex_test.rb
-* lib/win32/mutex.rb
-* test/test_win32_mutex.rb
+* CHANGES
+* INSTALL
+* MANIFEST
+* Rakefile
+* win32-mutex.gemspec
+* examples/mutex_test.rb
+* lib/win32/mutex.rb
+* test/test_win32_mutex.rb

data/README

@@ -1,51 +1,51 @@
-== Brief Description
-   Interface for Mutexes on MS Windows.
-
-== Prerequisites
-   win32-ipc 0.6.0 or later
-
-== Installation
-   gem install win32-mutex
-
-== Synopsis
-   require 'win32/mutex'
-
-   # Do not leave out the 'Win32::', otherwise you're using Ruby's Mutex class.
-   Win32::Mutex.new(false, 'test') do |m|
-     # Do stuff
-     m.release
-   end
-
-== Documentation
-   The mutex.rb file contains inline RDoc documentation. If you installed
-   this file as a gem, then you have the docs.
-
-   For an example of win32-mutex in action, look at the example_win32_mutex.rb
-   file in the 'examples' directory. You can also run the 'examples' rake task.
-
-== Notes
-   The Mutex class is a subclass of Win32::Ipc (win32-ipc). This library
-   require's the win32-ipc library internally. You don't need to explicitly
-   call it.
-
-== Acknowledgements
-   Originally adapted from the Win32::Mutex Perl module.
-
-== Known Bugs  
-   None that I know of. Please log any other bug reports on the
-   project page at https://github.com/djberg96/win32-mutex.
-    
-== License
-   Artistic 2.0
-    
-== Copyright
-   (C) 2003-2013 Daniel J. Berger, All Rights Reserved
-    
-== Warranty
-   This package is provided "as is" and without any express or
-   implied warranties, including, without limitation, the implied
-   warranties of merchantability and fitness for a particular purpose.
-
-== Authors
-   Daniel J. Berger
-   Park Heesob
+== Brief Description
+   Interface for Mutexes on MS Windows.
+
+== Prerequisites
+   win32-ipc 0.6.0 or later
+
+== Installation
+   gem install win32-mutex
+
+== Synopsis
+   require 'win32/mutex'
+
+   # Do not leave out the 'Win32::', otherwise you're using Ruby's Mutex class.
+   Win32::Mutex.new(false, 'test') do |m|
+     # Do stuff
+     m.release
+   end
+
+== Documentation
+   The mutex.rb file contains inline RDoc documentation. If you installed
+   this file as a gem, then you have the docs.
+
+   For an example of win32-mutex in action, look at the example_win32_mutex.rb
+   file in the 'examples' directory. You can also run the 'examples' rake task.
+
+== Notes
+   The Mutex class is a subclass of Win32::Ipc (win32-ipc). This library
+   require's the win32-ipc library internally. You don't need to explicitly
+   call it.
+
+== Acknowledgements
+   Originally adapted from the Win32::Mutex Perl module.
+
+== Known Bugs  
+   None that I know of. Please log any other bug reports on the
+   project page at https://github.com/djberg96/win32-mutex.
+    
+== License
+   Artistic 2.0
+    
+== Copyright
+   (C) 2003-2013 Daniel J. Berger, All Rights Reserved
+    
+== Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+== Authors
+   Daniel J. Berger
+   Park Heesob

data/Rakefile

@@ -1,31 +1,36 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/clean'
-
-CLEAN.include("**/*.gem")
-
-namespace :gem do
-  desc 'Create the win32-mutex gem'
-  task :create => [:clean] do
-    spec = eval(IO.read('win32-mutex.gemspec'))
-    Gem::Builder.new(spec).build
-  end
-
-  desc 'Install the win32-mutex gem'
-  task :install => [:create] do
-    file = Dir["*.gem"].first
-    sh "gem install #{file}"
-  end
-end
-
-desc 'Run the example program'
-task :example do
-  ruby '-Ilib examples/example_win32_mutex.rb'
-end
-
-Rake::TestTask.new do |t|
-  t.verbose = true
-  t.warning = true
-end
-
-task :default => :test
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+
+CLEAN.include("**/*.gem")
+
+namespace :gem do
+  desc 'Create the win32-mutex gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('win32-mutex.gemspec'))
+    if Gem::VERSION < "2.0.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
+  end
+
+  desc 'Install the win32-mutex gem'
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file}"
+  end
+end
+
+desc 'Run the example program'
+task :example do
+  ruby '-Ilib examples/example_win32_mutex.rb'
+end
+
+Rake::TestTask.new do |t|
+  t.verbose = true
+  t.warning = true
+end
+
+task :default => :test

data/examples/example_win32_mutex.rb

@@ -1,65 +1,65 @@
-##############################################################
-# example_win32_mutex.rb
-#
-# A test script for general futzing.  Modify as you see fit.
-# This test script requires win32-process and win32-mmap.
-##############################################################
-MUTEXNAME = "This is a very long name"
-
-require 'win32/mutex'
-require 'win32/process'
-require 'win32/mmap'
-include Win32
-
-pid = Process.fork
-
-# child_1
-if pid.nil?
-   mm = MMap.open('test')
-   mx = Win32::Mutex.open(MUTEXNAME)
-   5.times{   
-      mx.wait
-      puts "child_1 wait "
-      mm.gvalue += 123
-      sleep 1
-      mm.gvalue -= 123
-      mx.release
-      puts "child_1 release "
-   }
-   exit 1
-end
-
-pid2 = Process.fork
-
-# child_2
-if pid2.nil?
-   mm = MMap.open('test')
-   mx = Win32::Mutex.open(MUTEXNAME)
-   4.times{
-      mx.wait
-      puts "child_2 wait "
-      mm.gvalue += 456
-      sleep 2
-      mm.gvalue -= 456
-      mx.release
-      puts "child_2 release "
-   }
-   exit 1
-end
-
-#parent
-mm = MMap.new(:size => 1024, :name => 'test', :inherit => true)
-mm.gvalue = 5
-mx = Win32::Mutex.new(false, MUTEXNAME)
-
-3.times{
-   mx.wait
-   puts "parent wait"
-   sleep 5
-   printf("Value of GValue=%d\n", mm.gvalue)
-   mx.release
-   puts "parent release"
-}
-
-p Process.waitpid2(pid)
+##############################################################
+# example_win32_mutex.rb
+#
+# A test script for general futzing.  Modify as you see fit.
+# This test script requires win32-process and win32-mmap.
+##############################################################
+MUTEXNAME = "This is a very long name"
+
+require 'win32/mutex'
+require 'win32/process'
+require 'win32/mmap'
+include Win32
+
+pid = Process.fork
+
+# child_1
+if pid.nil?
+   mm = MMap.open('test')
+   mx = Win32::Mutex.open(MUTEXNAME)
+   5.times{   
+      mx.wait
+      puts "child_1 wait "
+      mm.gvalue += 123
+      sleep 1
+      mm.gvalue -= 123
+      mx.release
+      puts "child_1 release "
+   }
+   exit 1
+end
+
+pid2 = Process.fork
+
+# child_2
+if pid2.nil?
+   mm = MMap.open('test')
+   mx = Win32::Mutex.open(MUTEXNAME)
+   4.times{
+      mx.wait
+      puts "child_2 wait "
+      mm.gvalue += 456
+      sleep 2
+      mm.gvalue -= 456
+      mx.release
+      puts "child_2 release "
+   }
+   exit 1
+end
+
+#parent
+mm = MMap.new(:size => 1024, :name => 'test', :inherit => true)
+mm.gvalue = 5
+mx = Win32::Mutex.new(false, MUTEXNAME)
+
+3.times{
+   mx.wait
+   puts "parent wait"
+   sleep 5
+   printf("Value of GValue=%d\n", mm.gvalue)
+   mx.release
+   puts "parent release"
+}
+
+p Process.waitpid2(pid)
 p Process.waitpid2(pid2)

data/lib/win32/mutex.rb

@@ -1,146 +1,146 @@
-require 'win32/ipc'
-
-# The Win32 module serves as a namespace only.
-module Win32
-
-  # The Mutex class encapsulates Windows mutex objects.
-  class Mutex < Ipc
-    typedef :ulong, :dword
-    typedef :uintptr_t, :handle
-
-    ffi_lib :kernel32
-
-    private
-
-    class SecurityAttributes < FFI::Struct
-      layout(
-        :nLength, :dword,
-        :lpSecurityDescriptor, :pointer,
-        :bInheritHandle, :bool
-      )
-    end
-
-    attach_function :CreateMutexW, [:pointer, :bool, :buffer_in], :handle
-    attach_function :OpenMutexW, [:dword, :bool, :buffer_in], :handle
-    attach_function :ReleaseMutex, [:handle], :bool
-
-    private_class_method :CreateMutexW, :OpenMutexW, :ReleaseMutex
-
-    INVALID_HANDLE_VALUE = 0xFFFFFFFF
-    MUTEX_ALL_ACCESS     = 0x1F0001
-
-    public
-
-    # The version of the win32-mutex library
-    VERSION = '0.4.1'
-
-    # The name of the mutex object.
-    attr_reader :name
-
-    # Creates and returns new Mutex object. If +name+ is omitted, the
-    # Mutex object is created without a name, i.e. it's anonymous.
-    #
-    # If the +initial_owner+ value is true and the caller created the mutex,
-    # the calling thread obtains initial ownership of the mutex object.
-    # Otherwise, the calling thread does not obtain ownership of the mutex.
-    # This value is false by default.
-    #
-    # If +name+ is provided and it already exists, then it is opened
-    # instead, and the +initial_count+ and +max_count+ parameters are
-    # ignored.
-    #
-    # The +inherit+ attribute determines whether or not the mutex can
-    # be inherited by child processes.
-    #
-    def initialize(initial_owner=false, name=nil, inherit=true)
-      @initial_owner = initial_owner
-      @name          = name
-      @inherit       = inherit
-
-      if inherit
-        sec = SecurityAttributes.new
-        sec[:nLength] = SecurityAttributes.size
-        sec[:bInheritHandle] = true
-      else
-        sec = nil
-      end
-
-      if name && name.encoding.to_s != 'UTF-16LE'
-        name = name + 0.chr
-        name.encode!('UTF-16LE')
-      end
-
-      handle = CreateMutexW(sec, initial_owner, name)
-
-      if handle == 0 || handle == INVALID_HANDLE_VALUE
-        raise SystemCallError.new("CreateMutex", FFI.errno)
-      end
-
-      super(handle)
-
-      if block_given?
-        begin
-          yield self
-        ensure
-          close # From superclass
-        end
-      end
-    end
-
-    # Open an existing Mutex by +name+. The +inherit+ argument sets
-    # whether or not the object was opened such that a process created by the
-    # CreateProcess() function (a Windows API function) can inherit the
-    # handle. The default is true.
-    #
-    # This method is essentially identical to Mutex.new, except that the
-    # option for +initial_owner+ cannot be set (since it is already set).
-    # Also, this method will raise a Mutex::Error if the mutex doesn't
-    # already exist.
-    #
-    # If you want "open or create" semantics, then use Mutex.new.
-    #
-    def self.open(name, inherit=true, &block)
-      if name.encoding.to_s != 'UTF-16LE'
-        name = name + 0.chr
-        name.encode!('UTF-16LE')
-      end
-
-      begin
-        # The OpenMutex() call here is strictly to force an error if the user
-        # tries to open a mutex that doesn't already exist.
-        handle = OpenMutexW(MUTEX_ALL_ACCESS, inherit, name)
-
-        if handle == 0 || handle == INVALID_HANDLE_VALUE
-          raise SystemCallError.new("OpenMutex", FFI.errno)
-        end
-      ensure
-        CloseHandle(handle) if handle && handle > 0
-      end
-
-      self.new(false, name, inherit, &block)
-    end
-
-    # Releases ownership of the mutex.
-    #
-    def release
-      unless ReleaseMutex(@handle)
-        raise SystemCallError.new("ReleaseMutex", FFI.errno)
-      end
-    end
-
-    # Returns whether or not the calling thread has initial ownership of
-    # the mutex object.
-    #
-    def initial_owner?
-      @initial_owner
-    end
-
-    # Returns whether or not the object was opened such that a process
-    # created by the CreateProcess() function (a Windows API function) can
-    # inherit the handle. The default is true.
-    #
-    def inheritable?
-      @inherit
-    end
-  end
-end
+require 'win32/ipc'
+
+# The Win32 module serves as a namespace only.
+module Win32
+
+  # The Mutex class encapsulates Windows mutex objects.
+  class Mutex < Ipc
+    typedef :ulong, :dword
+    typedef :uintptr_t, :handle
+
+    ffi_lib :kernel32
+
+    private
+
+    class SecurityAttributes < FFI::Struct
+      layout(
+        :nLength, :dword,
+        :lpSecurityDescriptor, :pointer,
+        :bInheritHandle, :bool
+      )
+    end
+
+    attach_function :CreateMutexW, [:pointer, :bool, :buffer_in], :handle
+    attach_function :OpenMutexW, [:dword, :bool, :buffer_in], :handle
+    attach_function :ReleaseMutex, [:handle], :bool
+
+    private_class_method :CreateMutexW, :OpenMutexW, :ReleaseMutex
+
+    INVALID_HANDLE_VALUE = FFI::Pointer.new(-1).address
+    MUTEX_ALL_ACCESS     = 0x1F0001
+
+    public
+
+    # The version of the win32-mutex library
+    VERSION = '0.4.2'
+
+    # The name of the mutex object.
+    attr_reader :name
+
+    # Creates and returns new Mutex object. If +name+ is omitted, the
+    # Mutex object is created without a name, i.e. it's anonymous.
+    #
+    # If the +initial_owner+ value is true and the caller created the mutex,
+    # the calling thread obtains initial ownership of the mutex object.
+    # Otherwise, the calling thread does not obtain ownership of the mutex.
+    # This value is false by default.
+    #
+    # If +name+ is provided and it already exists, then it is opened
+    # instead, and the +initial_count+ and +max_count+ parameters are
+    # ignored.
+    #
+    # The +inherit+ attribute determines whether or not the mutex can
+    # be inherited by child processes.
+    #
+    def initialize(initial_owner=false, name=nil, inherit=true)
+      @initial_owner = initial_owner
+      @name          = name
+      @inherit       = inherit
+
+      if inherit
+        sec = SecurityAttributes.new
+        sec[:nLength] = SecurityAttributes.size
+        sec[:bInheritHandle] = true
+      else
+        sec = nil
+      end
+
+      if name && name.encoding.to_s != 'UTF-16LE'
+        name = name + 0.chr
+        name.encode!('UTF-16LE')
+      end
+
+      handle = CreateMutexW(sec, initial_owner, name)
+
+      if handle == 0 || handle == INVALID_HANDLE_VALUE
+        raise SystemCallError.new("CreateMutex", FFI.errno)
+      end
+
+      super(handle)
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          close # From superclass
+        end
+      end
+    end
+
+    # Open an existing Mutex by +name+. The +inherit+ argument sets
+    # whether or not the object was opened such that a process created by the
+    # CreateProcess() function (a Windows API function) can inherit the
+    # handle. The default is true.
+    #
+    # This method is essentially identical to Mutex.new, except that the
+    # option for +initial_owner+ cannot be set (since it is already set).
+    # Also, this method will raise a Mutex::Error if the mutex doesn't
+    # already exist.
+    #
+    # If you want "open or create" semantics, then use Mutex.new.
+    #
+    def self.open(name, inherit=true, &block)
+      if name.encoding.to_s != 'UTF-16LE'
+        name = name + 0.chr
+        name.encode!('UTF-16LE')
+      end
+
+      begin
+        # The OpenMutex() call here is strictly to force an error if the user
+        # tries to open a mutex that doesn't already exist.
+        handle = OpenMutexW(MUTEX_ALL_ACCESS, inherit, name)
+
+        if handle == 0 || handle == INVALID_HANDLE_VALUE
+          raise SystemCallError.new("OpenMutex", FFI.errno)
+        end
+      ensure
+        CloseHandle(handle) if handle && handle > 0
+      end
+
+      self.new(false, name, inherit, &block)
+    end
+
+    # Releases ownership of the mutex.
+    #
+    def release
+      unless ReleaseMutex(@handle)
+        raise SystemCallError.new("ReleaseMutex", FFI.errno)
+      end
+    end
+
+    # Returns whether or not the calling thread has initial ownership of
+    # the mutex object.
+    #
+    def initial_owner?
+      @initial_owner
+    end
+
+    # Returns whether or not the object was opened such that a process
+    # created by the CreateProcess() function (a Windows API function) can
+    # inherit the handle. The default is true.
+    #
+    def inheritable?
+      @inherit
+    end
+  end
+end

data/test/test_win32_mutex.rb

@@ -1,85 +1,85 @@
-# encoding: utf-8
-#######################################################################
-# test_win32_mutex.rb
-#
-# Test suite for the win32-mutex library. This test suite should be
-# run via the 'rake test' task.
-#######################################################################
-require 'test-unit'
-require 'win32/mutex'
-
-class TC_Win32_Mutex < Test::Unit::TestCase
-  def setup
-    @mutex  = Win32::Mutex.new(true, 'test')
-    @umutex = Win32::Mutex.new(false, 'Ηελλας')
-  end
-
-  test "version is set to expected value" do
-    assert_equal('0.4.1', Win32::Mutex::VERSION)
-  end
-
-  test "constructor with no arguments works as expected" do
-    mutex = nil
-    assert_nothing_raised{ mutex = Win32::Mutex.new }
-    mutex.close
-  end
-
-  test "default attributes are set to expected values" do
-    mutex = Win32::Mutex.new
-    assert_false(mutex.initial_owner?)
-    assert_true(mutex.inheritable?)
-    assert_nil(mutex.name)
-    mutex.close
-  end
-
-  test "open method works as expected" do
-    assert_respond_to(Win32::Mutex, :open)
-    assert_nothing_raised{ Win32::Mutex.open('test'){} }
-    assert_nothing_raised{ Win32::Mutex.open('Ηελλας'){} }
-  end
-
-  test "attempting to open an unknown mutex raises an error" do
-    assert_raise(Errno::ENOENT){ Win32::Mutex.open('bogus'){} }
-  end
-
-  test "release method works as expected" do
-    assert_respond_to(@mutex, :release)
-    assert_nothing_raised{ @mutex.release }
-  end
-
-  test "initial_owner? works as expected and returns expected value" do
-    assert_respond_to(@mutex, :initial_owner?)
-    assert_true(@mutex.initial_owner?)
-    assert_false(@umutex.initial_owner?)
-  end
-
-  test "inheritable? works as expected and returns expected value" do
-    assert_respond_to(@mutex, :inheritable?)
-    assert_true(@mutex.inheritable?)
-  end
-
-  test "wait method was inherited" do
-    assert_respond_to(@mutex, :wait)
-  end
-
-  test "wait_any method was inherited" do
-    assert_respond_to(@mutex, :wait_any)
-  end
-
-  test "wait_all method was inherited" do
-    assert_respond_to(@mutex, :wait_all)
-  end
-
-  test "ffi functions are private" do
-    assert_not_respond_to(Win32::Mutex, :CreateMutexW)
-    assert_not_respond_to(Win32::Mutex, :OpenMutexW)
-    assert_not_respond_to(Win32::Mutex, :ReleaseMutex)
-  end
-
-  def teardown
-    @mutex.close
-    @umutex.close
-    @mutex = nil
-    @umutex = nil
-  end
-end
+# encoding: utf-8
+#######################################################################
+# test_win32_mutex.rb
+#
+# Test suite for the win32-mutex library. This test suite should be
+# run via the 'rake test' task.
+#######################################################################
+require 'test-unit'
+require 'win32/mutex'
+
+class TC_Win32_Mutex < Test::Unit::TestCase
+  def setup
+    @mutex  = Win32::Mutex.new(true, 'test')
+    @umutex = Win32::Mutex.new(false, 'Ηελλας')
+  end
+
+  test "version is set to expected value" do
+    assert_equal('0.4.2', Win32::Mutex::VERSION)
+  end
+
+  test "constructor with no arguments works as expected" do
+    mutex = nil
+    assert_nothing_raised{ mutex = Win32::Mutex.new }
+    mutex.close
+  end
+
+  test "default attributes are set to expected values" do
+    mutex = Win32::Mutex.new
+    assert_false(mutex.initial_owner?)
+    assert_true(mutex.inheritable?)
+    assert_nil(mutex.name)
+    mutex.close
+  end
+
+  test "open method works as expected" do
+    assert_respond_to(Win32::Mutex, :open)
+    assert_nothing_raised{ Win32::Mutex.open('test'){} }
+    assert_nothing_raised{ Win32::Mutex.open('Ηελλας'){} }
+  end
+
+  test "attempting to open an unknown mutex raises an error" do
+    assert_raise(Errno::ENOENT){ Win32::Mutex.open('bogus'){} }
+  end
+
+  test "release method works as expected" do
+    assert_respond_to(@mutex, :release)
+    assert_nothing_raised{ @mutex.release }
+  end
+
+  test "initial_owner? works as expected and returns expected value" do
+    assert_respond_to(@mutex, :initial_owner?)
+    assert_true(@mutex.initial_owner?)
+    assert_false(@umutex.initial_owner?)
+  end
+
+  test "inheritable? works as expected and returns expected value" do
+    assert_respond_to(@mutex, :inheritable?)
+    assert_true(@mutex.inheritable?)
+  end
+
+  test "wait method was inherited" do
+    assert_respond_to(@mutex, :wait)
+  end
+
+  test "wait_any method was inherited" do
+    assert_respond_to(@mutex, :wait_any)
+  end
+
+  test "wait_all method was inherited" do
+    assert_respond_to(@mutex, :wait_all)
+  end
+
+  test "ffi functions are private" do
+    assert_not_respond_to(Win32::Mutex, :CreateMutexW)
+    assert_not_respond_to(Win32::Mutex, :OpenMutexW)
+    assert_not_respond_to(Win32::Mutex, :ReleaseMutex)
+  end
+
+  def teardown
+    @mutex.close
+    @umutex.close
+    @mutex = nil
+    @umutex = nil
+  end
+end

data/win32-mutex.gemspec

@@ -1,27 +1,29 @@
-require 'rubygems'
-
-Gem::Specification.new do |spec|
-  spec.name      = 'win32-mutex'
-  spec.version   = '0.4.1'
-  spec.author    = 'Daniel J. Berger'
-  spec.license   = 'Artistic 2.0'
-  spec.email     = 'djberg96@gmail.com'
-  spec.homepage  = 'https://github.com/djberg96/win32-mutex'
-  spec.summary   = 'Interface to MS Windows Mutex objects.'
-  spec.test_file = 'test/test_win32_mutex.rb'
-  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
-
-  spec.rubyforge_project = 'win32utils'
-  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
-  spec.required_ruby_version = '> 1.9.0'
-
-  spec.add_dependency('win32-ipc', '>= 0.6.0')
-  spec.add_development_dependency('test-unit')
-
-  spec.description = <<-EOF
-    The win32-mutex library provides an interface for creating mutex objects
-    on MS Windows. A mutex object is a synchronization object whose state
-    is set to signaled when it is not owned by any thread, and non-signaled
-    when it is owned.
-  EOF
-end
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name      = 'win32-mutex'
+  spec.version   = '0.4.2'
+  spec.author    = 'Daniel J. Berger'
+  spec.license   = 'Artistic 2.0'
+  spec.email     = 'djberg96@gmail.com'
+  spec.homepage  = 'https://github.com/djberg96/win32-mutex'
+  spec.summary   = 'Interface to MS Windows Mutex objects.'
+  spec.test_file = 'test/test_win32_mutex.rb'
+  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.rubyforge_project = 'win32utils'
+  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+  spec.required_ruby_version = '> 1.9.0'
+
+  spec.add_dependency('win32-ipc', '>= 0.6.0')
+
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('test-unit')
+
+  spec.description = <<-EOF
+    The win32-mutex library provides an interface for creating mutex objects
+    on MS Windows. A mutex object is a synchronization object whose state
+    is set to signaled when it is not owned by any thread, and non-signaled
+    when it is owned.
+  EOF
+end

metadata

@@ -1,52 +1,62 @@
 --- !ruby/object:Gem::Specification
 name: win32-mutex
 version: !ruby/object:Gem::Version
-  version: 0.4.1
-  prerelease: 
+  version: 0.4.2
 platform: ruby
 authors:
 - Daniel J. Berger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-10 00:00:00.000000000 Z
+date: 2013-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: win32-ipc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "    The win32-mutex library provides an interface for creating mutex
-  objects\n    on MS Windows. A mutex object is a synchronization object whose state\n
-  \   is set to signaled when it is not owned by any thread, and non-signaled\n    when
-  it is owned.\n"
+description: |2
+      The win32-mutex library provides an interface for creating mutex objects
+      on MS Windows. A mutex object is a synchronization object whose state
+      is set to signaled when it is not owned by any thread, and non-signaled
+      when it is owned.
 email: djberg96@gmail.com
 executables: []
 extensions: []
@@ -66,27 +76,26 @@ files:
 homepage: https://github.com/djberg96/win32-mutex
 licenses:
 - Artistic 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - '>'
     - !ruby/object:Gem::Version
       version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: win32utils
-rubygems_version: 1.8.24
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Interface to MS Windows Mutex objects.
 test_files:
 - test/test_win32_mutex.rb