win32-api 1.4.6-x86-mingw32

data/test/test_win32_api.rb

@@ -0,0 +1,140 @@
+############################################################################
+# test_win32_api.rb
+# 
+# Test case for the Win32::API class. You should run this as Rake task,
+# i.e. 'rake test', instead of running it directly.
+############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'win32/api'
+require 'test/unit'
+include Win32
+
+class TC_Win32_API < Test::Unit::TestCase
+   def setup
+      @buf = 0.chr * 260
+      @gfa = API.new('GetFileAttributes', 'S', 'L')
+      @gcd = API.new('GetCurrentDirectory', 'LP')
+      @gle = API.new('GetLastError', 'V', 'L')
+      @str = API.new('strstr', 'PP', 'P', 'msvcrt')
+   end
+
+   def test_version
+      assert_equal('1.4.5', API::VERSION)
+   end
+
+   def test_constructor_basic
+      assert_nothing_raised{ API.new('GetCurrentDirectory') }
+      assert_nothing_raised{ API.new('GetCurrentDirectory', 'LP') }
+      assert_nothing_raised{ API.new('GetCurrentDirectory', 'LP', 'L') }
+      assert_nothing_raised{ API.new('GetCurrentDirectory', 'LP', 'L', 'kernel32') }
+   end
+ 
+   def test_call
+      assert_respond_to(@gcd, :call)
+      assert_nothing_raised{ @gcd.call(@buf.length, @buf) }
+      assert_equal(Dir.pwd.tr('/', "\\"), @buf.strip)
+   end
+   
+   def test_call_with_void
+      assert_nothing_raised{ @gle.call }
+      assert_nothing_raised{ @gle.call(nil) }
+   end
+
+   def test_call_return_value_on_failure
+      assert_equal(0xFFFFFFFF, @gfa.call('C:/foobarbazblah'))
+   end
+   
+   def test_dll_name
+      assert_respond_to(@gcd, :dll_name)
+      assert_equal('kernel32', @gcd.dll_name)
+   end
+   
+   def test_function_name
+      assert_respond_to(@gcd, :function_name)
+      assert_equal('GetCurrentDirectory', @gcd.function_name)
+      assert_equal('strstr', @str.function_name)
+   end
+   
+   def test_effective_function_name_default
+      assert_respond_to(@gcd, :effective_function_name)
+      assert_equal('GetCurrentDirectoryA', @gcd.effective_function_name)
+      assert_equal('strstr', @str.effective_function_name)
+   end
+
+   def test_effective_function_name_default_explicit_ansi
+      @gcd = API.new('GetCurrentDirectoryA', 'LP')
+      assert_equal('GetCurrentDirectoryA', @gcd.effective_function_name)
+   end
+
+   def test_effective_function_name_default_explicit_wide
+      @gcd = API.new('GetCurrentDirectoryW', 'LP')
+      assert_equal('GetCurrentDirectoryW', @gcd.effective_function_name)
+   end
+   
+   def test_prototype
+      assert_respond_to(@gcd, :prototype)
+      assert_equal(['L', 'P'], @gcd.prototype)
+   end
+   
+   def test_return_type
+      assert_respond_to(@gcd, :return_type)
+      assert_equal('L', @gcd.return_type)
+   end
+   
+   def test_constructor_high_iteration
+      assert_nothing_raised{
+         1000.times{ API.new('GetUserName', 'P', 'P', 'advapi32') }
+      }
+   end
+   
+   def test_constructor_expected_failures
+      assert_raise(ArgumentError){ API.new }
+      assert_raise(ArgumentError){ API.new('GetUserName', ('L' * 21), 'X') }
+      assert_raise(API::LoadLibraryError){ API.new('GetUserName', 'PL', 'I', 'foo') }
+      assert_raise(API::PrototypeError){ API.new('GetUserName', 'X', 'I', 'advapi32') }
+      assert_raise(API::PrototypeError){ API.new('GetUserName', 'PL', 'X', 'advapi32') }
+   end
+
+   def test_constructor_expected_failure_messages
+      assert_raise_message("Unable to load function 'Zap', 'ZapA', or 'ZapW'"){
+         API.new('Zap')
+      }
+
+      assert_raise_message("Unable to load function 'strxxx'"){
+         API.new('strxxx', 'P', 'L', 'msvcrt')
+      }
+
+      assert_raise_message("Illegal prototype 'X'"){
+         API.new('GetUserName', 'X', 'I', 'advapi32')
+      }
+
+      assert_raise_message("Illegal return type 'Y'"){
+         API.new('GetUserName', 'PL', 'Y', 'advapi32')
+      }
+   end
+
+   def test_call_expected_failures
+      assert_raise(TypeError){ @gcd.call('test', @buf) }
+   end
+
+   def test_error_classes
+      assert_not_nil(Win32::API::Error)
+      assert_not_nil(Win32::API::LoadLibraryError)
+      assert_not_nil(Win32::API::PrototypeError)
+   end
+
+   def test_error_class_relationships
+      assert_kind_of(RuntimeError, Win32::API::Error.new)
+      assert_kind_of(Win32::API::Error, Win32::API::LoadLibraryError.new)
+      assert_kind_of(Win32::API::Error, Win32::API::PrototypeError.new)
+   end
+
+   def teardown
+      @buf = nil
+      @gcd = nil
+      @gle = nil
+      @str = nil
+   end
+end

data/test/test_win32_api_callback.rb

@@ -0,0 +1,74 @@
+############################################################################
+# test_win32_api_callback.rb
+# 
+# Test case for the Win32::API::Callback class. You should run this as Rake
+# task, i.e. 'rake test', instead of running it directly.
+############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'win32/api'
+require 'test/unit'
+include Win32
+
+class TC_Win32_API_Callback < Test::Unit::TestCase
+  def setup
+    @buffer   = 0.chr * 260
+    @api_ew   = API.new('EnumWindows', 'KP', 'L', 'user32')
+    @api_gwt  = API.new('GetWindowText', 'LPI', 'I', 'user32')
+    @callback = nil
+  end
+   
+  def test_constructor
+    assert_respond_to(API::Callback, :new)
+    assert_nothing_raised{ API::Callback.new('LP', 'I') }
+    assert_nothing_raised{ API::Callback.new('LP', 'I'){} }
+  end
+   
+  def test_prototype
+    assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
+    assert_respond_to(@callback, :prototype)
+    assert_equal('LP', @callback.prototype)
+  end
+   
+  def test_return_value
+    assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
+    assert_respond_to(@callback, :return_type)
+    assert_equal('I', @callback.return_type)
+  end
+
+  def test_address
+    assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
+    assert_respond_to(@callback, :address)
+    assert_kind_of(Integer, @callback.address)
+    assert_true(@callback.address > 0)
+  end
+   
+  def test_callback
+    assert_nothing_raised{
+      @callback = API::Callback.new('LP', 'I'){ |handle, param|
+       	buf = "\0" * 200
+        @api_gwt.call(handle, buf, 200);
+        buf.index(param).nil? ? true : false           
+      }
+    }
+    assert_nothing_raised{ @api_ew.call(@callback, 'UEDIT32') }
+  end
+   
+  def test_constructor_expected_errors
+    assert_raise(API::PrototypeError){ API::Callback.new('X') }
+    assert_raise(API::PrototypeError){ API::Callback.new('L', 'Y') }
+  end
+
+  def test_constructor_expected_error_messages
+    assert_raise_message("Illegal prototype 'X'"){ API::Callback.new('X') }
+    assert_raise_message("Illegal return type 'Y'"){ API::Callback.new('L', 'Y') }
+  end
+
+  def teardown
+    @buffer   = nil
+    @api_ew   = nil
+    @api_gwt  = nil
+    @callback = nil
+  end
+end

data/test/test_win32_api_function.rb

@@ -0,0 +1,66 @@
+########################################################################
+# test_win32_api_function.rb
+#
+# Test case for the Win32::API::Function class. You should run these
+# tests via the 'rake test' task.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'win32/api'
+include Win32
+
+class TC_Win32_API_Function < Test::Unit::TestCase
+   def setup
+      @func = Win32::API::Function.new(123456789, 'LP', 'L')
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Win32::API::Function.new(1) }
+      assert_nothing_raised{ Win32::API::Function.new(1, 'LL') }
+      assert_nothing_raised{ Win32::API::Function.new(1, 'LL', 'I') }
+   end
+   
+   def test_subclass
+      assert_kind_of(Win32::API, @func)
+      assert_respond_to(@func, :call)
+   end
+
+   def test_address
+      assert_respond_to(@func, :address)
+      assert_equal(123456789, @func.address)
+   end
+
+   def test_prototype
+      assert_respond_to(@func, :prototype)
+      assert_equal(['L', 'P'], @func.prototype)
+   end
+
+   def test_return_type
+      assert_respond_to(@func, :return_type)
+      assert_equal('L', @func.return_type)
+   end
+
+   def test_expected_errors_from_arguments
+      assert_raise(ArgumentError){ Win32::API::Function.new }
+      assert_raise(TypeError){ Win32::API::Function.new('L') }
+      assert_raise(Win32::API::PrototypeError){ Win32::API::Function.new(1, 'X') }
+      assert_raise(Win32::API::PrototypeError){ Win32::API::Function.new(1, 'X', 'Y') }
+   end
+
+   def test_expected_error_messages
+      assert_raise_message("Illegal prototype 'X'"){ API::Function.new(1, 'X') }
+      assert_raise_message("Illegal return type 'Y'"){ API::Function.new(1, 'L', 'Y') }
+   end
+
+   def test_expected_errors_from_call
+      assert_raise(ArgumentError){ @func.call }
+      assert_raise(ArgumentError){ @func.call(1) }
+      assert_raise(ArgumentError){ @func.call(1, 'a', 2) }
+   end
+
+   def teardown
+      @func = nil
+   end
+end

data/win32-api.gemspec

@@ -0,0 +1,29 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'win32-api'
+  spec.version    = '1.4.6'
+  spec.authors    = ['Daniel J. Berger', 'Park Heesob']
+  spec.license    = 'Artistic 2.0'
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://www.rubyforge.org/projects/win32utils'
+  spec.platform   = Gem::Platform::RUBY
+  spec.summary    = 'A superior replacement for Win32API'
+  spec.has_rdoc   = true
+  spec.test_files = Dir['test/test*']
+  spec.extensions = ['ext/extconf.rb']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+   
+  spec.rubyforge_project = 'win32utils'
+  spec.required_ruby_version = '>= 1.8.2'
+  spec.extra_rdoc_files = ['README', 'CHANGES', 'MANIFEST', 'ext/win32/api.c']
+   
+  spec.add_development_dependency('test-unit', '>= 2.0.6')
+   
+  spec.description = <<-EOF
+    The Win32::API library is meant as a replacement for the Win32API
+    library that ships as part of the standard library. It contains several
+    advantages over Win32API, including callback support, raw function
+    pointers, an additional string type, and more.
+  EOF
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: win32-api
+version: !ruby/object:Gem::Version 
+  version: 1.4.6
+platform: x86-mingw32
+authors: 
+- Daniel J. Berger
+- Park Heesob
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.6
+    version: 
+description: "    The Win32::API library is meant as a replacement for the Win32API\n    library that ships as part of the standard library. It contains several\n    advantages over Win32API, including callback support, raw function\n    pointers, an additional string type, and more.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- MANIFEST
+- ext/win32/api.c
+files: 
+- CHANGES
+- lib/win32/api.so
+- MANIFEST
+- Rakefile
+- README
+- test/test_win32_api.rb
+- test/test_win32_api_callback.rb
+- test/test_win32_api_function.rb
+- win32-api.gemspec
+- ext/win32/api.c
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/win32utils
+licenses: 
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: win32utils
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A superior replacement for Win32API
+test_files: 
+- test/test_win32_api.rb
+- test/test_win32_api_callback.rb
+- test/test_win32_api_function.rb