win 0.3.11 → 0.3.16

data/spec/spec_helper.rb

@@ -61,14 +61,22 @@ def os
   @os_flag ||= cygwin? ? `cmd /c ver` : `ver`
 end
 
-def vista?
-  os =~ /Version 6/
+def os_2000?
+  os =~ /Version 5.0/
 end
 
-def xp?
+def os_xp?
   os =~ /XP/
 end
 
+def os_vista?
+  os =~ /Version 6.0/
+end
+
+def os_7?
+  os =~ /Version 6.1/
+end
+
 module WinTest
 
   KEY_DELAY = 0.001
@@ -96,6 +104,10 @@ module WinTest
   def buffer
     FFI::MemoryPointer.new(:char, 1024)
   end
+
+  def pointer(type=:long, num=1)
+    FFI::MemoryPointer.new(type, num)
+  end
 end
 
 module WinTestApp

data/spec/win/error_spec.rb

@@ -69,7 +69,7 @@ module WinErrorTest
       end
     end # describe set_last_error
 
-    if xp? || vista? # This function works only on XP++
+    if os_xp? || os_vista? # This function works only on XP++
       describe "#set_last_error_ex" do
         spec{ use{ SetLastErrorEx(dw_err_code=0, dw_type=0) }}
         spec{ use{ set_last_error_ex(dw_err_code=0, dw_type=0) }}
@@ -86,7 +86,7 @@ module WinErrorTest
       end # describe set_last_error_ex
     end
 
-    if vista? # This function works only on Vista++
+    if os_vista? || os_7? # This function works only on Vista++
       describe "#get_error_mode" do
         spec{ use{ mode = GetErrorMode() }}
         spec{ use{ mode = get_error_mode() }}

data/spec/win/gui/message_spec.rb

@@ -49,11 +49,27 @@ module WinGuiMessageTest
       spec{ use{ success = PostMessage(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
       spec{ use{ success = post_message(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
 
-      it 'places (posts) a message in the message queue associated with the thread that created the specified window' do
-        app = launch_test_app
-        post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil).should == true
-        sleep SLEEP_DELAY
-        window?(app.handle).should == false
+      context 'places (posts) a message in the message queue associated with the thread that created the specified window' do
+        it 'with nil as last argument(lParam)' do
+          app = launch_test_app
+          post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil).should == true
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
+
+        it 'with pointer as last argument(lParam)' do
+          app = launch_test_app
+          post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, FFI::MemoryPointer.new(:long)).should == true
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
+
+        it 'with Fixnum as last argument(lParam)' do
+          app = launch_test_app
+          post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, 0).should == true
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
       end
 
       it 'places (posts) a message into current thread`s queue if first arg is 0' do
@@ -126,11 +142,11 @@ module WinGuiMessageTest
         send_message_callback(not_a_handle, WM_USER, 0, nil){|*args|@data=args[2]}
         sent.should == 0
         get_last_error.should == "Invalid window handle."
-       end
+      end
     end # describe send_message_callback
 
     describe "#get_message" do
-      before(:all){clear_thread_queue; 2.times {post_message 0,0,0,nil}}
+      before(:all){clear_thread_queue; 2.times {post_message 0, 0, 0, nil}}
 
       spec{ use{ res = GetMessage(msg, handle=0, msg_filter_min=0, msg_filter_max=0) }}
       spec{ use{ message = get_message(msg, handle=0, msg_filter_min=0, msg_filter_max=0) }}

data/spec/win/library_spec.rb

@@ -13,8 +13,8 @@ module WinLibraryTest
   def should_be symbol, api
     case symbol
       when :find_window
-        #api.dll_name.should == 'user32' # The name of the DLL that exports the API function
-        api.effective_function_name.should == 'FindWindowA' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
+        api.dll.should include "user32" # The name of the DLL that exports the API function
+        api.effective_function_name.should == :FindWindowA # Actual function: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
         api.function_name.should == :FindWindow # The name of the function passed to the constructor
         api.prototype.should == [:pointer, :pointer] # The prototype, returned as an array of characters
         api.return_type.should == :ulong # The prototype, returned as an array of characters
@@ -43,13 +43,12 @@ module WinLibraryTest
   end
 
   def redefined_methods
-    [:FindWindow, :IsWindow, :EnumWindows, :GetComputerName, :GetForegroundWindow]
+    [:FindWindow, :IsWindow, :EnumWindows, :GetUserName, :GetForegroundWindow, :keybd_event]
   end
 
   def hide_method(*names) # hide original method(s) if it is defined
     names.map(&:to_s).each do |name|
       MyLib.module_eval do
-        # + remove_const
         aliases = generate_names(name).flatten + [name]
         aliases.map(&:to_s).each do |ali|
           if method_defined? ali
@@ -76,20 +75,162 @@ module WinLibraryTest
     end
   end
 
+  shared_examples_for 'defining macro with options' do
+    context 'basic behavior' do
+      it 'defines new instance methods with appropriate names' do
+        MyLib.function :FindWindow, 'PP', 'L', &@def_block
+        MyLib.respond_to?(:FindWindow).should be_true
+        respond_to?(:FindWindow).should be_true
+        MyLib.respond_to?(:find_window).should be_true
+        respond_to?(:find_window).should be_true
+      end
+
+      it 'returns underlying Win32::API object' do
+        FWAPI = MyLib.function :FindWindow, 'PP', 'L', &@def_block
+        should_be :find_window, FWAPI
+      end
+    end
+
+    context 'renaming and aliasing' do
+      it ':camel_name option overrides default CamelCase name for attached function but leaves snake_case intact' do
+        MyLib.function :FindWindow, 'PP', 'L', camel_name: 'MyOwnName', &@def_block
+        expect {find_window(nil, nil)}.to_not raise_error
+        expect {FindWindow(nil, nil)}.to raise_error NoMethodError
+        expect {MyOwnName(nil, nil)}.to_not raise_error
+      end
+
+      it ':snake_name option overrides default snake_case name for defined method but leaves CamelCase intact' do
+        MyLib.function :FindWindow, 'PP', 'L', snake_name: 'my_own_find', &@def_block
+        expect {find_window(nil, nil)}.to raise_error NoMethodError
+        expect {FindWindow(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+      end
+
+      it 'both :snake_name and :camel_name option can be used in one declaration' do
+        MyLib.function :FindWindow, 'PP', 'L', camel_name: 'MyOwnName', snake_name: 'my_own_find', &@def_block
+        expect {find_window(nil, nil)}.to raise_error NoMethodError
+        expect {my_own_find(nil, nil)}.to_not raise_error
+        expect {FindWindow(nil, nil)}.to raise_error NoMethodError
+        expect {MyOwnName(nil, nil)}.to_not raise_error
+      end
+
+      it ':camel_only option means no snake_case method will be defined' do
+        MyLib.function :FindWindow, 'PP', 'L', camel_only: true, &@def_block
+        expect {find_window(nil, nil)}.to raise_error NoMethodError
+        expect {FindWindow(nil, nil)}.to_not raise_error
+      end
+
+      it 'automatically adds Rubyesque alias to IsXxx API test function' do
+        MyLib.function 'IsWindow', 'L', 'B', &@def_block
+        respond_to?(:window?).should be_true
+        respond_to?(:is_window).should be_true
+      end
+
+      it 'automatically adds Rubyesque alias to GetXxx API getter function' do
+        MyLib.function 'GetForegroundWindow', [], 'L', &@def_block
+        respond_to?(:get_foreground_window).should be_true
+        respond_to?(:foreground_window).should be_true
+      end
+
+      it ':alias option adds alias for defined snake_case method' do
+        MyLib.function( :FindWindow, 'PP', 'L', :alias => 'my_own_find', &@def_block)
+        expect {find_window(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+      end
+
+      it ':aliases option adds aliases for defined snake_case method' do
+        MyLib.function :FindWindow, 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1'], &@def_block
+        expect {find_window(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+        expect {my_own_find1(nil, nil)}.to_not raise_error
+      end
+    end
+
+    context ':boolean option converts result to boolean' do
+      before(:each) { MyLib.function :FindWindow, 'PP', 'L', :boolean => true, &@def_block }
+
+      it 'defines new instance method' do
+        respond_to?(:find_window).should be_true
+        respond_to?(:FindWindow).should be_true
+      end
+
+      it 'defined snake_case method returns false/true instead of zero/non-zero' do
+        find_window(nil, nil).should == true
+        find_window(nil, IMPOSSIBLE).should == false
+      end
+
+      it 'defined CamelCase method still returns zero/non-zero' do
+        FindWindow(nil, nil).should_not == true
+        FindWindow(nil, nil).should_not == 0
+        FindWindow(nil, IMPOSSIBLE).should == 0
+      end
+    end
+
+    context 'defining API with :zeronil option converts zero result to nil' do
+      before(:each) {MyLib.function :FindWindow, 'PP', 'L', :zeronil => true, &@def_block}
+
+      it 'defines new instance method' do
+        respond_to?(:find_window).should be_true
+        respond_to?(:FindWindow).should be_true
+      end
+
+      it 'defined CamelCase method still returns zero/non-zero' do
+        FindWindow(nil, nil).should_not == true
+        FindWindow(nil, nil).should_not == 0
+        FindWindow(nil, IMPOSSIBLE).should == 0
+      end
+
+      it 'defined method returns nil (but NOT false) instead of zero' do
+        find_window(nil, IMPOSSIBLE).should_not == false
+        find_window(nil, IMPOSSIBLE).should == nil
+      end
+
+      it 'defined method does not return true when result is non-zero' do
+        find_window(nil, nil).should_not == true
+        find_window(nil, nil).should_not == 0
+      end
+    end
+
+    context 'using DLL other than default user32, kernel32 with :dll option' do
+      before(:each){  MyLib.function 'GetUserName', 'PP', 'I', :dll=> 'advapi32', &@def_block}
+
+      it 'defines new instance method with appropriate name' do
+        respond_to?(:GetUserName).should be_true
+        respond_to?(:get_user_name).should be_true
+        respond_to?(:user_name).should be_true
+      end
+
+      it 'returns expected result' do
+        username = `echo %USERNAME%`.strip
+        name_ptr = FFI::MemoryPointer.from_string(" " * 128)
+        size_ptr = FFI::MemoryPointer.new(:long).write_int(name_ptr.size)
+        get_user_name(name_ptr, size_ptr)
+        name_ptr.read_string.strip.should == username
+      end
+    end
+  end
+
   describe Win::Library, ' defines wrappers for Win32::API functions' do
 
     before(:each) { hide_method *redefined_methods } # hide original methods if  defined
     after(:each) { restore_method *redefined_methods } # restore original methods if hidden
-    context '::function' do
-      context 'defining enhanced API function method' do
-        spec{ use{ MyLib.function(:FindWindow, 'PP', 'l', rename: nil, aliases: nil, boolean: nil, zeronil: nil, &any_block) }}
 
-        it 'defines new instance methods with appropriate names' do
-          MyLib.function :FindWindow, 'PP', 'L'
-          respond_to?(:FindWindow).should be_true
-          MyLib.respond_to?(:find_window).should be_true
-          respond_to?(:find_window).should be_true
-        end
+    describe '::attach_function - delegates to FFI::Library::attach_function' do
+      it 'can be used to attach same function with different signatures' do
+        MyLib.attach_function :send_one, :SendMessageA, [:ulong, :uint, :uint, :long], :int
+        MyLib.attach_function :send_two, :SendMessageA, [:ulong, :uint, :uint, :pointer], :int
+        respond_to?(:send_one).should be_true
+        respond_to?(:send_two).should be_true
+        MyLib.respond_to?(:send_one).should be_true
+        MyLib.respond_to?(:send_two).should be_true
+      end
+    end
+
+    describe '::function - attaches external API function and defines enhanced snake_case method on top of it' do
+      spec{ use{ MyLib.function(:FindWindow, 'PP', 'l', aliases: nil, boolean: nil, zeronil: nil, &any_block) }}
+
+      context 'defining enhanced API function without defenition block (using defaults)' do
+        it_should_behave_like 'defining macro with options'
 
         it 'constructs argument prototype from uppercase string, enforces the args count' do
           expect { MyLib.function :FindWindow, 'PP', 'L' }.to_not raise_error
@@ -101,13 +242,6 @@ module WinLibraryTest
           should_count_args :find_window, :FindWindow, [nil, nil], [nil, IMPOSSIBLE, 'cmd']
         end
 
-        it 'with :rename option, overrides snake_case name for defined method but leaves CamelCase intact' do
-          MyLib.function :FindWindow, 'PP', 'L', :rename=> 'my_own_find'
-          expect {find_window(nil, nil)}.to raise_error NoMethodError
-          expect {FindWindow(nil, nil)}.to_not raise_error
-          expect {my_own_find(nil, nil)}.to_not raise_error
-        end
-
         it 'defined snake_case method returns expected value when called' do
           MyLib.function :FindWindow, 'PP', 'L'
           find_window(nil, nil).should_not == 0
@@ -130,123 +264,14 @@ module WinLibraryTest
 #        should_be :find_window, find_window(:api)
 #      end
 
-        it 'returns underlying Win32::API object' do
-          FWAPI = MyLib.function :FindWindow, 'PP', 'L'
-          should_be :find_window, FWAPI
-        end
       end
 
-      context 'defining aliases' do
-        it 'adds alias for defined method with :alias option' do
-          MyLib.function( :FindWindow, 'PP', 'L', :alias => 'my_own_find')
-          expect {find_window(nil, nil)}.to_not raise_error
-          expect {my_own_find(nil, nil)}.to_not raise_error
+      context 'defining API function using explicit definition block' do
+        before(:each) do
+          @def_block = lambda{|api, *args| api.call(*args)}  # Trivial define_block for shared examples
         end
 
-        it 'adds aliases for defined method with :aliases option' do
-          MyLib.function :FindWindow, 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1']
-          expect {find_window(nil, nil)}.to_not raise_error
-          expect {my_own_find(nil, nil)}.to_not raise_error
-          expect {my_own_find1(nil, nil)}.to_not raise_error
-        end
-
-        it 'adds Rubyesque alias to IsXxx API test function' do
-          MyLib.function 'IsWindow', 'L', 'B'
-          respond_to?(:window?).should be_true
-          respond_to?(:is_window).should be_true
-        end
-
-        it 'adds Rubyesque alias to GetXxx API getter function' do
-          MyLib.function 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'
-          respond_to?(:get_computer_name).should be_true
-          respond_to?(:computer_name).should be_true
-        end
-      end
-
-      context 'defining API with :boolean option converts result to boolean' do
-        before(:each) { MyLib.function :FindWindow, 'PP', 'L', :boolean => true }
-
-        it 'defines new instance method' do
-          respond_to?(:find_window).should be_true
-          respond_to?(:FindWindow).should be_true
-        end
-
-        it 'defined snake_case method returns false/true instead of zero/non-zero' do
-          find_window(nil, nil).should == true
-          find_window(nil, IMPOSSIBLE).should == false
-        end
-
-        it 'defined CamelCase method still returns zero/non-zero' do
-          FindWindow(nil, nil).should_not == true
-          FindWindow(nil, nil).should_not == 0
-          FindWindow(nil, IMPOSSIBLE).should == 0
-        end
-
-        it 'defined methods enforce the argument count' do
-          should_count_args :find_window, :FindWindow, [nil, nil], [nil, IMPOSSIBLE, 'cmd']
-        end
-      end
-
-      context 'defining API with :zeronil option converts zero result to nil' do
-        before(:each) {MyLib.function :FindWindow, 'PP', 'L', :zeronil => true}
-
-        it 'defines new instance method' do
-          respond_to?(:find_window).should be_true
-          respond_to?(:FindWindow).should be_true
-        end
-
-        it 'defined CamelCase method still returns zero/non-zero' do
-          FindWindow(nil, nil).should_not == true
-          FindWindow(nil, nil).should_not == 0
-          FindWindow(nil, IMPOSSIBLE).should == 0
-        end
-
-        it 'defined method returns nil (but NOT false) instead of zero' do
-          find_window(nil, IMPOSSIBLE).should_not == false
-          find_window(nil, IMPOSSIBLE).should == nil
-        end
-
-        it 'defined method does not return true when result is non-zero' do
-          find_window(nil, nil).should_not == true
-          find_window(nil, nil).should_not == 0
-        end
-
-        it 'defined methods enforce the argument count' do
-          should_count_args :find_window, :FindWindow, [nil, nil], [nil, IMPOSSIBLE, 'cmd']
-        end
-      end
-
-      context 'using DLL other than default user32 with :dll option' do
-        before(:each) {MyLib.function 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'}
-
-        it 'defines new instance method with appropriate name' do
-          respond_to?(:GetComputerName).should be_true
-          respond_to?(:get_computer_name).should be_true
-          respond_to?(:computer_name).should be_true
-        end
-
-        it 'returns expected result' do
-          MyLib.function 'GetComputerName', ['P', 'P'], 'I', :dll=> 'kernel32'
-          hostname = `hostname`.strip.upcase
-          name = " " * 128
-          get_computer_name(name, "128")
-          name.unpack("A*").first.should == hostname
-        end
-      end
-
-      context 'trying to define an invalid API function' do
-        it 'raises error when trying to define function with a wrong function name' do
-          expect { MyLib.function 'FindWindowImpossible', 'PP', 'L' }.
-                  to raise_error( /Function 'FindWindowImpossible' not found/ )
-        end
-      end
-
-      context 'defining API function using definition block' do
-        it 'defines new instance method' do
-          MyLib.function( :FindWindow, 'PP', 'L' ){|api, *args|}
-          respond_to?(:find_window).should be_true
-          respond_to?(:FindWindow).should be_true
-        end
+        it_should_behave_like 'defining macro with options'
 
         it 'does not enforce argument count outside of block' do
           MyLib.function( :FindWindow, 'PP', 'L' ){|api, *args|}
@@ -269,24 +294,12 @@ module WinLibraryTest
           @args.should == [1, 2, 3]
           should_be :find_window, @api
         end
+      end
 
-        it ':rename option overrides standard name for defined method' do
-          MyLib.function( :FindWindow, 'PP', 'L', :rename => 'my_own_find' ){|api, *args|}
-          expect {find_window(nil, nil, nil)}.to raise_error
-          expect {my_own_find(nil, nil)}.to_not raise_error
-        end
-
-        it 'adds alias for defined method with :alias option' do
-          MyLib.function( :FindWindow, 'PP', 'L', :alias => 'my_own_find' ){|api, *args|}
-          expect {find_window(nil, nil)}.to_not raise_error
-          expect {my_own_find(nil, nil)}.to_not raise_error
-        end
-
-        it 'adds aliases for defined method with :aliases option' do
-          MyLib.function( :FindWindow, 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1'] ) {|api, *args|}
-          expect {find_window(nil, nil)}.to_not raise_error
-          expect {my_own_find(nil, nil)}.to_not raise_error
-          expect {my_own_find1(nil, nil)}.to_not raise_error
+      context 'trying to define an invalid API function' do
+        it 'raises error when trying to define function with a wrong function name' do
+          expect { MyLib.function 'FindWindowImpossible', 'PP', 'L' }.
+                  to raise_error( /Function 'FindWindowImpossible' not found/ )
         end
       end
 
@@ -316,22 +329,35 @@ module WinLibraryTest
           should_count_args :GetForegroundWindow, :get_foreground_window, :foreground_window, [], [nil, 0, 123]
         end
       end
+
+      context 'defining API function that has snake_case name' do
+        it 'should define original function in (generated) CamelCase' do
+          MyLib.function :keybd_event, [:char, :char, :ulong, :ulong], :void
+          expect {KeybdEvent(Win::Gui::Input::VK_CONTROL, 0, Win::Gui::Input::KEYEVENTF_KEYDOWN, 0)}.to_not raise_error
+          expect {keybd_event(Win::Gui::Input::VK_CONTROL, 0, Win::Gui::Input::KEYEVENTF_KEYUP, 0)}.to_not raise_error
+        end
+      end
     end
 
     context '::callback defining API callback TYPES' do
-      it '#callback macro creates a valid callback definition' do
+      it '#callback macro defines a valid callback TYPE' do
         expect { MyLib.callback :MyEnumWindowsProc, [:HWND, :long], :bool}.to_not raise_error
       end
 
-      it 'created callback definition can be used to define API function expecting callback' do
+      it 'pre-definsed callback type can be used to define API functions (expecting callback)' do
         expect {MyLib.function :EnumWindows, [:MyEnumWindowsProc, :long], :long}.to_not raise_error
+        expect {MyLib.function :EnumWindows, [:UndefinedProc, :long], :long}.to raise_error TypeError
+      end
+
+      it 'API function expecting callback accept lambdas representing callback' do
+        MyLib.function :EnumWindows, [:MyEnumWindowsProc, :long], :long
         expect { enum_windows(lambda{|handle, message| true }, 0) }.to_not raise_error
       end
     end
 
-    context '::try_function to define API function that are platform-specific' do
-      if xp?
-        it 'should silently fail to define function not present on current platform' do
+    context '::try_function - possibly defines API functions that are platform-specific' do
+      if os_xp?
+        it 'silently fails to define function not present on current platform' do
           expect {MyLib.function :GetErrorMode, [], :UINT}.to raise_error /Function 'GetErrorMode' not found/
           expect {MyLib.try_function :GetErrorMode, [], :UINT}.to_not raise_error
           expect { GetErrorMode() }.to raise_error /undefined method `GetErrorMode'/