win32-api 1.2.1-x86-mswin32-60 → 1.2.2-x86-mswin32-60

data/CHANGES

@@ -1,3 +1,18 @@
+= 1.2.2 - 27-Nov-2008
+* Fixed bug in the error message for illegal prototypes and illegal return
+  types where the character in question would come out as empty or garbage.
+* Passing a bad return type to Win32::API::Callback now raises an error.
+* Updated the error message for illegal return types to say, "Illegal return
+  type" instead of "Illegal prototype" as it did previously.
+* The error message for a bad function name passed to Win32::API.new now
+  matches JRuby's FFI error message.
+* Improved the handling of msvcrt functions with regards to skipping 'A'
+  and 'W' checks. Previously it was checking against the literal string
+  'msvcrt'. Now it checks against any string that starts with 'msvcr'.
+* Added test-unit 2.x as a prerequisite.
+* Added tests for the Win32::API::Callback#address method.
+* Added tests to all Win32::API classes that explicitly check error messages.
+
 = 1.2.1 - 14-Nov-2008
 * Fixed and updated callback handling.
 * Fixed wide string return handling for pointers and strings.

data/ext/win32/api.c

@@ -2,7 +2,7 @@
 #include <windows.h>
 
 #define MAX_BUF 1024
-#define WINDOWS_API_VERSION "1.2.1"
+#define WINDOWS_API_VERSION "1.2.2"
 
 #define _T_VOID     0
 #define _T_LONG     1
@@ -123,12 +123,24 @@ static VALUE callback_init(int argc, VALUE* argv, VALUE self)
             break;
          default:
             rb_raise(cCallbackError, "Illegal prototype '%c'",
-               RSTRING(v_proto)->ptr[i]);
+               RSTRING(v_proto)->ptr[i]
+            );
       }
    }
 
-   if(NIL_P(v_return) || RARRAY(v_return)->len == 0)
+   if(NIL_P(v_return) || RARRAY(v_return)->len == 0){
       v_return = rb_str_new2("L");
+   }
+   else{
+      switch(*(char*)RSTRING(v_return)->ptr){
+         case 'I': case 'L': case 'P': case 'V': case 'S':
+            break;
+         default:
+            rb_raise(cCallbackError, "Illegal return type '%s'",
+               RSTRING(v_return)->ptr
+            );
+      }
+   }
 
    rb_iv_set(self, "@function", v_proc);
    rb_iv_set(self, "@prototype", v_proto);
@@ -243,10 +255,10 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
 
    // Skip the ANSI and Wide function checks for MSVCRT functions.
    if(!fProc){
-      if(!strcmp(RSTRING(v_dll)->ptr, "msvcrt")){
+      if(strstr(RSTRING(v_dll)->ptr, "msvcr")){
          rb_raise(
             cAPIError,
-            "GetProcAddress() failed for '%s': %s",
+            "Unable to load function '%s'",
             RSTRING(v_proc)->ptr,
             StringError(GetLastError())
          );
@@ -264,11 +276,10 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
             if(!fProc){
                rb_raise(
                   cAPIError,
-                  "GetProcAddress() failed for '%s', '%s' and '%s': %s",
+                  "Unable to load function '%s', '%s', or '%s'",
                   RSTRING(v_proc)->ptr,
                   RSTRING(v_ascii)->ptr,
-                  RSTRING(v_unicode)->ptr,
-                  StringError(GetLastError())
+                  RSTRING(v_unicode)->ptr
                );
             }
             else{
@@ -310,7 +321,9 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
             ptr->prototype[i] = _T_STRING;
             break;
          default:
-            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
+            rb_raise(cAPIError, "Illegal prototype '%s'",
+               StringValuePtr(RARRAY(v_proto)->ptr[i])
+            );
       }
    }
 
@@ -340,7 +353,9 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
             ptr->return_type = _T_STRING;
             break;
          default:
-            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
+            rb_raise(cAPIError, "Illegal return type '%s'",
+               RSTRING(v_return)->ptr
+            );
       }
    }
 
@@ -432,7 +447,9 @@ static VALUE func_init(int argc, VALUE* argv, VALUE self){
             ptr->prototype[i] = _T_STRING;
             break;
          default:
-            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
+            rb_raise(cAPIError, "Illegal prototype '%s'",
+               StringValuePtr(RARRAY(v_proto)->ptr[i])
+            );
       }
    }
 
@@ -462,7 +479,9 @@ static VALUE func_init(int argc, VALUE* argv, VALUE self){
             ptr->return_type = _T_STRING;
             break;
          default:
-            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
+            rb_raise(cAPIError, "Illegal return type '%s'",
+               RSTRING(v_return)->ptr
+            );
       }
    }
 
@@ -510,7 +529,9 @@ DWORD CallbackFunction(CALLPARAM param)
                  argv[i] = INT2NUM(param.params[i]);
                  break;
               default:
-                 rb_raise(cCallbackError, "Illegal prototype '%c'", a_proto[i]);
+                 rb_raise(cCallbackError, "Illegal prototype '%s'",
+                    RSTRING(a_proto[i])->ptr
+                 );
             }
         }
 
@@ -845,6 +866,6 @@ void Init_api(){
 
    /* Constants */
 
-   /* 1.2.0: The version of this library, returned as a String */
+   /* 1.2.2: The version of this library, returned as a String */
    rb_define_const(cAPI, "VERSION", rb_str_new2(WINDOWS_API_VERSION));
 }

data/test/test_win32_api.rb

@@ -4,6 +4,9 @@
 # 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
@@ -17,7 +20,7 @@ class TC_Win32_API < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('1.2.1', API::VERSION)
+      assert_equal('1.2.2', API::VERSION)
    end
 
    def test_constructor_basic
@@ -49,14 +52,18 @@ class TC_Win32_API < Test::Unit::TestCase
       assert_equal('strstr', @str.function_name)
    end
    
-   def test_effective_function_name
+   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
@@ -79,43 +86,30 @@ class TC_Win32_API < Test::Unit::TestCase
    
    def test_constructor_expected_failures
       assert_raise(ArgumentError){ API.new }
+      assert_raise(ArgumentError){ API.new('GetUserName', ('L' * 17), 'X') }
       assert_raise(API::Error){ API.new('GetUserName', 'PL', 'I', 'foo') }
       assert_raise(API::Error){ API.new('GetUserName', 'X', 'I', 'kernel32') }
       assert_raise(API::Error){ API.new('GetUserName', 'PL', 'X', 'kernel32') }
    end
 
-   # Compare MSVCRT error messages vs regular error messages. This validates
-   # that we're skipping the 'A' and 'W' lookups for MSVCRT functions.
-   #
-   # The JRuby test message is somewhat different because we're not using
-   # GetLastError().
-   #
    def test_constructor_expected_failure_messages
-      begin
-         API.new('GetBlah')
-      rescue API::Error => err
-         if RUBY_PLATFORM.match('java')
-            expected = "Unable to load function 'GetBlah', 'GetBlahA', or 'GetBlahW'"
-         else
-            expected = "GetProcAddress() failed for 'GetBlah', 'GetBlahA' and "
-            expected += "'GetBlahW': The specified procedure could not be found."
-         end
-         assert_equal(expected, err.to_s)
-      end
+      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')
+      }
 
-      begin
-         API.new('strxxx', 'P', 'P', 'msvcrt')
-      rescue API::Error => err
-         if RUBY_PLATFORM.match('java')
-            expected = "Unable to load function 'strxxx'"
-         else
-            expected = "GetProcAddress() failed for 'strxxx': The specified "
-            expected += "procedure could not be found."
-         end
-         assert_equal(expected, err.to_s)
-      end
+      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

data/test/test_win32_api_callback.rb

@@ -4,6 +4,9 @@
 # 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
@@ -33,6 +36,13 @@ class TC_Win32_API_Callback < Test::Unit::TestCase
       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(Fixnum, @callback.address)
+      assert_equal(true, @callback.address > 0)
+   end
    
    def test_callback
       assert_nothing_raised{
@@ -47,6 +57,12 @@ class TC_Win32_API_Callback < Test::Unit::TestCase
    
    def test_constructor_expected_errors
       assert_raise(API::Callback::Error){ API::Callback.new('X') }
+      assert_raise(API::Callback::Error){ 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

data/test/test_win32_api_function.rb

@@ -4,8 +4,12 @@
 # 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
@@ -38,8 +42,22 @@ class TC_Win32_API_Function < Test::Unit::TestCase
       assert_equal('L', @func.return_type)
    end
 
-   def test_expected_errors
+   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::Error){ Win32::API::Function.new(1, 'X') }
+      assert_raise(Win32::API::Error){ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win32-api
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
+  version: 1.2.2
 platform: x86-mswin32-60
 authors: 
 - Daniel J. Berger
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-14 00:00:00 -07:00
+date: 2008-11-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -56,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: win32utils
-rubygems_version: 1.2.0
+rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
 summary: A superior replacement for Win32API