win 0.1.18 → 0.1.22

data/spec/win/dde_spec.rb

@@ -4,6 +4,7 @@ require 'win/dde'
 module WinDDETest
   include WinTest
   include Win::DDE
+  include Win::GUI::Message
 
   def dde_cmd
     APPCLASS_STANDARD
@@ -21,6 +22,19 @@ module WinDDETest
     FFI::MemoryPointer.new(:char, 1024)
   end
 
+  def string_pointer
+    FFI::MemoryPointer.from_string("Pointer_string")
+  end
+
+  def extract_values(*args)
+    type, format, conv, hsz1, hsz2, data, data1, data2 = *args
+    @server_conv = conv
+    [Win::DDE::TYPES[type], format, conv,
+     dde_query_string(@client_id, hsz1),
+     dde_query_string(@client_id, hsz2),
+     data, data1, data2]
+  end
+
   describe Win::DDE, ' contains a set of pre-defined Windows API functions' do
     describe 'register_clipboard_format' do
       spec{ use{ RegisterClipboardFormat(format_name = "XlTable") }}
@@ -44,48 +58,50 @@ module WinDDETest
     end
 
     describe 'dde_initialize' do
+      after(:each) {dde_uninitialize(@instance_id) if @instance_id}
+
       spec{ use{ status = DdeInitialize( zero_id, dde_callback, dde_cmd, unused = 0)}}
       spec{ use{ id, status = dde_initialize( instance_id = 0, dde_cmd) do|*args|
       end }}
 
       it 'with zero instance_id, returns integer id and DMLERR_NO_ERROR if initialization successful' do
-        id, status = dde_initialize(0, APPCLASS_STANDARD) {|*args| }
-        id.should be_an Integer
-        id.should_not == 0
+        @instance_id, status = dde_initialize(0, APPCLASS_STANDARD) {|*args| }
+        @instance_id.should be_an Integer
+        @instance_id.should_not == 0
         status.should == DMLERR_NO_ERROR
       end
 
       it 'with nil instance_id, returns integer id and DMLERR_NO_ERROR if initialization successful' do
-        id, status = dde_initialize(nil, APPCLASS_STANDARD) {|*args| }
-        id.should be_an Integer
-        id.should_not == 0
+        @instance_id, status = dde_initialize(nil, APPCLASS_STANDARD) {|*args| }
+        @instance_id.should be_an Integer
+        @instance_id.should_not == 0
         status.should == DMLERR_NO_ERROR
       end
 
       it 'with omitted instance_id, returns integer id and DMLERR_NO_ERROR if initialization successful' do
-        id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }
-        id.should be_an Integer
-        id.should_not == 0
+        @instance_id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }
+        @instance_id.should be_an Integer
+        @instance_id.should_not == 0
         status.should == DMLERR_NO_ERROR
       end
 
       it 'returns error status if initialization unsuccessful' do
-        id, status = dde_initialize(1, APPCLASS_STANDARD) {|*args| }
+        @instance_id, status = dde_initialize(12345, APPCLASS_STANDARD) {|*args| }
         status.should == DMLERR_INVALIDPARAMETER
-        id.should == nil
+        @instance_id.should == nil
       end
 
       it 'is able to reinitialize with correct id' do
-        id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }
-        new_id, status = dde_initialize(id, APPCLASS_STANDARD) {|*args| }
+        @instance_id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }
+        new_id, status = dde_initialize(@instance_id, APPCLASS_STANDARD) {|*args| }
         status.should == DMLERR_NO_ERROR
-        new_id.should == id
+        new_id.should == @instance_id
       end
     end
 
     context 'after initialization:' do
       before(:each) {@instance_id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }}
-      after(:each) {dde_uninitialize(@instance_id)}
+      after(:each) {dde_uninitialize(@instance_id) if @instance_id}
 
       describe '#dde_uninitialize' do
 
@@ -101,47 +117,50 @@ module WinDDETest
           res = dde_uninitialize(12345)
           res.should == false
         end
-      end
+      end # describe '#dde_uninitialize'
 
       describe '#dde_create_string_handle' do
-        spec{ use{ string_handle = DdeCreateStringHandle(instance_id=0, string='Any String', code_page_id=CP_WINANSI) }}
-        spec{ use{ string_handle = dde_create_string_handle(instance_id=0, string='Any String', code_page_id=CP_WINANSI)}}
+        after(:each) {dde_free_string_handle(@instance_id, @string_handle) if @string_handle}
+
+        spec{ use{ @string_handle = DdeCreateStringHandle(instance_id=0, string_pointer, code_page_id=CP_WINANSI) }}
+        spec{ use{ @string_handle = dde_create_string_handle(instance_id=0, string='Any String', code_page_id=CP_WINANSI)}}
 
         it 'returns nonzero Integer handle to a string (passable to other DDEML functions)' do
-          string_handle = dde_create_string_handle(@instance_id, 'My String', CP_WINANSI)
-          string_handle.should be_an Integer
-          string_handle.should_not == 0
+          @string_handle = dde_create_string_handle(@instance_id, 'My String', CP_WINANSI)
+          @string_handle.should be_an Integer
+          @string_handle.should_not == 0
         end
 
         it 'creates handle even if code_page is omitted' do
-          string_handle = dde_create_string_handle(@instance_id, 'My String')
-          string_handle.should be_an Integer
-          string_handle.should_not == 0
+          @string_handle = dde_create_string_handle(@instance_id, 'My String')
+          @string_handle.should be_an Integer
+          @string_handle.should_not == 0
         end
 
         it 'creating two handles for the SAME string (inside one instance) USUALLY returns same handle' do
-          string_handle1 = dde_create_string_handle(@instance_id, 'My String')
+          @string_handle = dde_create_string_handle(@instance_id, 'My String')
           10.times do
-            string_handle2 = dde_create_string_handle(@instance_id, 'My String')
-            string_handle1.should == string_handle2
+            string_handle1 = dde_create_string_handle(@instance_id, 'My String')
+            string_handle1.should == @string_handle
+            dde_free_string_handle(@instance_id, string_handle1)
           end
         end
 
         it 'created different handles for two different strings ' do
-          string_handle1 = dde_create_string_handle(@instance_id, 'My String')
-          string_handle2 = dde_create_string_handle(@instance_id, 'My String1')
-          string_handle1.should_not == string_handle2
+          @string_handle = dde_create_string_handle(@instance_id, 'My String')
+          string_handle1 = dde_create_string_handle(@instance_id, 'My String1')
+          string_handle1.should_not == @string_handle
+          dde_free_string_handle(@instance_id, string_handle1)
         end
 
         it 'returns nil if unable to register handle to a string' do
-          string_handle = dde_create_string_handle(@instance_id, "", CP_WINANSI)
-          string_handle.should == nil
+          @string_handle = dde_create_string_handle(@instance_id, "", CP_WINANSI)
+          @string_handle.should == nil
         end
+      end # describe '#dde_create_string_handle'
 
-      end
-
-      context "with dde string handle to 'My String':" do
-        before(:each) {@string_handle = dde_create_string_handle(@instance_id, 'My String', CP_WINANSI)}
+      context "with dde string handle to 'My String 2'" do
+        before(:each) {@string_handle = dde_create_string_handle(@instance_id, 'My String 2', CP_WINANSI)}
         after(:each) {dde_free_string_handle(@instance_id, @string_handle)}
 
         describe '#dde_query_string' do
@@ -151,19 +170,19 @@ module WinDDETest
 
           it 'retrieves string that given string handle refers to' do
             string = dde_query_string(@instance_id, @string_handle)
-            string.should == 'My String'
+            string.should == 'My String 2'
           end
 
           it 'retrieves string even if code_page is omitted' do
             string = dde_query_string(@instance_id, @string_handle)
-            string.should == 'My String'
+            string.should == 'My String 2'
           end
 
           it 'returns nil attempting to retrieve invalid handle' do
             string = dde_query_string(@instance_id, 12345)
             string.should == nil
           end
-        end
+        end # describe '#dde_query_string'
 
         describe '#dde_free_string_handle' do
 
@@ -179,21 +198,35 @@ module WinDDETest
             res = dde_free_string_handle(@instance_id, 12345)
             res.should == false
           end
-        end
+
+          it 'keeps string accessible if there are more handles to it around' do
+            string_handle_1 = dde_create_string_handle(@instance_id, 'My String 2', CP_WINANSI)
+
+            dde_free_string_handle(@instance_id, @string_handle)
+
+            dde_query_string(@instance_id, @string_handle).should == 'My String 2'
+            dde_free_string_handle(@instance_id, string_handle_1)
+          end
+
+          it 'makes string inaccessible once its last handle is freed' do
+            dde_free_string_handle(@instance_id, @string_handle)
+
+            dde_query_string(@instance_id, @string_handle).should == nil
+          end
+        end # describe '#dde_free_string_handle'
 
         describe '#dde_name_service' do
           spec{ use{ success = dde_name_service(@instance_id, @string_handle, cmd=DNS_UNREGISTER ) }}
           spec{ use{ success = DdeNameService(@instance_id, @string_handle, reserved=0, cmd=DNS_UNREGISTER) }}
 
           it 'registers or unregisters the service names that DDE server supports' do
-
             success = dde_name_service( @instance_id, @string_handle, DNS_REGISTER )
             success.should == true
 
             success = dde_name_service( @instance_id, @string_handle, DNS_UNREGISTER )
             success.should == true
           end
-        end
+        end # describe '#dde_name_service'
 
         describe '#dde_get_last_error' do
           spec{ use{ error_code = DdeGetLastError( @instance_id) }}
@@ -211,9 +244,109 @@ module WinDDETest
             dde_name_service( @instance_id, 1234, DNS_REGISTER )
             dde_get_last_error( @instance_id).should == DMLERR_INVALIDPARAMETER
           end
-        end
+        end # describe '#dde_get_last_error'
+
+      end # context "with dde string handle to 'My String'"
+    end # context 'after initialization:'
+
+    context 'with synthetic DDE client/server' do
+      before(:each) do
+        @client_calls = []
+        @server_calls = []
+        @client_id, status = dde_initialize(APPCLASS_STANDARD) {|*args| @client_calls << extract_values(*args); 1}
+        @server_id, status = dde_initialize(APPCLASS_STANDARD) {|*args| @server_calls << extract_values(*args); 1}
+        @service_handle = dde_create_string_handle(@server_id, 'service 2', CP_WINANSI)
+        @topic_handle = dde_create_string_handle(@client_id, 'topic 2', CP_WINANSI)
+        dde_name_service(@server_id, @service_handle, DNS_REGISTER)
+      end
+
+      after(:each) do
+#        p @server_calls, @client_calls, @server_conv
+#        p ERRORS[dde_get_last_error(@server_id)]
+#        p ERRORS[dde_get_last_error(@client_id)]
 
+        dde_name_service(@server_id, @service_handle, DNS_UNREGISTER)
+        dde_free_string_handle(@server_id, @service_handle)
+        dde_free_string_handle(@client_id, @topic_handle)
+        dde_uninitialize(@client_id)
+        dde_uninitialize(@server_id)
       end
+      
+      describe '#dde_connect' do
+        after(:each) { dde_disconnect(@conv_handle) if @conv_handle}
+        spec{ use{ @conv_handle = DdeConnect( instance_id=0, service=0, topic=0, context=nil) }}
+        spec{ use{ @conv_handle = dde_connect( instance_id=0, service=0, topic=0, context=nil) }}
+
+        it 'connects to existing DDE server (self in this case)' do
+          @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+
+          @server_calls.first[0].should == 'XTYP_CONNECT'
+          @server_calls.first[3].should == 'topic 2'
+          @server_calls.first[4].should == 'service 2'
+          @server_calls[1][0].should == 'XTYP_CONNECT_CONFIRM'
+          @server_calls[1][3].should == 'topic 2'
+          @server_calls[1][4].should == 'service 2'
+          dde_disconnect(@server_conv).should == true
+          dde_disconnect(@conv_handle).should == true
+          
+          p @server_calls, @client_calls, @conv_handle, @server_conv
+          p ERRORS[dde_get_last_error(@server_id)]
+          p ERRORS[dde_get_last_error(@client_id)]
+        end
+        
+        it 'connects to existing DDE server (NOT self)' do
+          pending 'something is wrong when connecting to separate service instance, uninitialize fails'
+          conv_handle = dde_connect( @client_id, @service_handle, @topic_handle, context=nil)
+          puts conv_handle
+          p @server_calls, @client_calls, @server_conv
+          p dde_disconnect(@server_conv) #conv_handle)
+#          p @server_calls, @client_calls
+        end
+      end # describe '#dde_connect'
+
+      describe '#dde_disconnect' do
+        spec{ use{ success = DdeDisconnect(conversation_handle=0) }}
+        spec{ use{ success = dde_disconnect(conversation_handle=0) }}
+
+        it 'fails to disconnect if not valid conversation handle given' do
+          dde_disconnect(12345).should == false
+        end
+
+        it 'disconnects from existing DDE server' do
+          pending 'XTYP_DISCONNECT is not received by server callback for some reason'
+        end
+      end # describe '#dde_disconnect'
+
+      describe "#dde_client_transaction" do
+        after(:each) do
+          p @server_calls, @client_calls, @server_conv
+          p ERRORS[dde_get_last_error(@server_id)]
+          p ERRORS[dde_get_last_error(@client_id)]
+        end
+
+        spec{ use{ res = DdeClientTransaction(data=nil, size=0, conv=0, item=0, format=0, type=0, timeout=0, result=nil) }}
+        spec{ use{ res = dde_client_transaction(data=nil, size=0, conv=0, item=0, format=0, type=0, timeout=0, result=nil) }}
+
+        it "original api is used by CLIENT to begins a data transaction with server" do
+#          pending 'weird error - wrong number of arguments (8 for 0)'
+          p @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+          str = FFI::MemoryPointer.from_string "Poke_string\n\x00\x00"
+#          res = DdeClientTransaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+          begin
+          get_message() if peek_message()
+          res = DdeClientTransaction(str, str.size, @conv_handle, @topic_handle, 0, XTYP_EXECUTE, 1000, nil)
+          p res
+          rescue => e
+            puts e.backtrace
+            raise e
+          end
+        end
+
+        it "snake_case api begins a data transaction between a client and a server. Only a Dynamic Data Exchange (DDE) client " do
+          pending
+          success = dde_client_transaction(p_data=0, cb_data=0, h_conv=0, hsz_item=0, w_fmt=0, w_type=0, dw_timeout=0, pdw_result=0)
+        end
+      end # describe dde_client_transaction
 
       describe '#dde_get_data' do
         spec{ use{ buffer, success = dde_get_data( data_handle = 123, max = 1073741823, offset = 0) }}
@@ -228,21 +361,18 @@ module WinDDETest
           dde_get_data( data_handle = 123, 3741823, 0).should == nil
         end
 
-      end
-
-      describe '#dde_connect' do
-        spec{ use{ conversation_handle = DdeConnect( instance_id=0, service=0, topic=0, context=nil) }}
-        spec{ use{ conversation_handle = dde_connect( instance_id=0, service=0, topic=0, context=nil) }}
+        it 'original API returns 1 if connect successful' do
+          pending
+          DdeGetData( data_handle = 123, nil, 0, 0).should == 0
+        end
 
-        it 'connects to existing DDE server'
-      end
+        it 'snake_case API returns returns true if connect successful' do
+          pending
+          dde_get_data( data_handle = 123, 3741823, 0).should == nil
+        end
 
-      describe '#dde_disconnect' do
-        spec{ use{ success = DdeDisconnect(conversation_handle=0) }}
-        spec{ use{ success = dde_disconnect(conversation_handle=0) }}
+      end # describe '#dde_get_data'
 
-        it 'disconnects from existing DDE server'
-      end
-    end
+    end # context 'with synthetic DDE server'
   end
-end
+end

data/spec/win/gui/message_spec.rb

@@ -1,37 +1,78 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'win/gui/input'
-#require 'win/gui/window'
+require 'win/error'
 
 module WinGUIMessageTest
 
   include WinTestApp
   include Win::GUI::Message
   include Win::GUI::Window
+  include Win::GUI::Input
+  include Win::Error
+
+  def buffer
+    @buffer ||= FFI::MemoryPointer.new :char, 1024
+  end
+
+  def msg
+    @msg ||=Win::GUI::Message::Msg.new
+  end
+
+  def msg_callback
+    lambda {|handle, message, data, result|  @handle = handle; @message = message; @data = data; @result = result }
+  end
+
+  def should_have msg, members
+    members.each do |member, value|
+      case member
+        when :l_param
+          msg[member].address.should == value
+        when :time
+          msg[member].should be > value
+        else
+          msg[member].should == value
+      end
+    end
+  end
+
+  def clear_thread_queue
+    get_message while peek_message
+  end
 
   describe Win::GUI::Message, ' defines a set of API functions related to Window messaging'  do
-    after(:each){close_test_app if @launched_test_app}
+    before(:all){clear_thread_queue}
 
     describe '#post_message' do
+      before(:each){clear_thread_queue}
+      after(:all){close_test_app if @launched_test_app}
+
       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)
+        post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil).should == true
         sleep TEST_SLEEP_DELAY
         window?(app.handle).should == false
       end
 
+      it 'places (posts) a message into current thread`s queue if first arg is 0' do
+        post_message(0, WM_USER, 33, nil).should == true
+        msg = get_message()
+        should_have msg, hwnd: 0, message: WM_USER, w_param: 33, l_param: 0
+      end
+
       it 'returns without waiting for the thread to process the message'
+
     end # describe '#post_message'
 
     describe '#send_message' do
-      spec{ use{ success = SendMessage(handle = 0, msg = 0, w_param = 1024, l_param = "\x0"*1024) }}
-      spec{ use{ success = send_message(handle = 0, msg = 0, w_param = 1024, l_param = "\x0"*1024) }}
+      spec{ use{ success = SendMessage(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
+      spec{ use{ success = send_message(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
 
-      it 'sends the specified message to a window or windows' do
+      it 'directly sends the specified message to a window or windows' do
         app = launch_test_app
-        buffer = FFI::MemoryPointer.new :char, 1024
+
         num_chars = send_message app.handle, WM_GETTEXT, buffer.size, buffer
         buffer.get_bytes(0, num_chars).should == "LockNote - Steganos LockNote"
 
@@ -39,10 +80,156 @@ module WinGUIMessageTest
         buffer.get_bytes(0, num_chars).should =~ /Welcome to Steganos LockNote/
 
         send_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil)
-        sleep TEST_SLEEP_DELAY
+        sleep TEST_SLEEP_DELAY  # delay to allow window close
         window?(app.handle).should == false
       end
     end # describe '#send_message'
+
+    # :call-seq:
+    #  success = send_message_callback(handle, msg, w_param, l_param, data)
+    #            {|handle, msg, data, l_result| callback code }
+
+    describe "#send_message_callback" do
+      before(:all){@app=launch_test_app}
+      after(:all){close_test_app if @launched_test_app}
+
+      spec{ use{ success = SendMessageCallback(h_wnd=0, msg=0, w_param=0, l_param=nil, msg_callback, data=0) }}
+      spec{ use{ success = send_message_callback(h_wnd=0, msg=0, w_param=0, l_param=nil, data=0, &msg_callback) }}
+
+      it "sends message to window and returns, specifying callback to be called by system after message is processed" do
+        sent = SendMessageCallback(@app.handle, WM_USER, 0, nil, msg_callback, data=13)
+        sent.should == 1
+        @handle.should == nil
+        @message.should == nil
+        @data.should == nil
+        @result.should == nil
+
+        sleep TEST_SLEEP_DELAY # small delay to allow message delivery
+        peek_message           # dispatching sent message (even though there is nothing in queue)
+
+        @handle.should == @app.handle
+        @message.should == WM_USER
+        @data.should == 13
+        @result.should == 0
+      end
+
+      it "snake_case api defaults data to 0, converts block into callback and returns true/false" do
+        sent = send_message_callback(@app.handle, WM_USER, 0, nil){|*args|@data=args[2]}
+        sent.should == true
+        @data.should == nil
+
+        sleep TEST_SLEEP_DELAY # small delay to allow message delivery
+        peek_message           # dispatching sent message (even though there is nothing in queue)
+
+        @data.should == 0
+      end
+
+      it "fails if unable to send message" do
+        sent = SendMessageCallback(not_a_handle, WM_USER, 0, nil, msg_callback, 0)
+        sent.should == 0
+        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 # describe send_message_callback
+
+    describe "#get_message" do
+      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) }}
+
+      it "original api retrieves a message from the calling thread's message queue" do
+        set_cursor_pos(x=0, y=0)
+        post_message(0, WM_USER+1, 33, nil)
+        res = GetMessage(msg, handle=0, msg_filter_min=0, msg_filter_max=0)
+        res.should == 1
+        # p msg[:hwnd], msg[:message], msg[:w_param], msg[:l_param], msg[:time], msg[:x], msg[:y]
+        should_have msg, hwnd: 0, message: WM_USER+1, w_param: 33, x: 0, y: 0, l_param: 0, time: 1000000
+      end
+
+      it "original api returns -1 if there is an error (wrong handle, in this case)" do
+        res = GetMessage(msg, not_a_handle, msg_filter_min=0, msg_filter_max=0)
+        res.should == -1
+      end
+
+      it "original api returns 0 if WM_QUIT was posted to thread`s message queue" do
+        post_message(0, WM_QUIT, 13, nil)
+        res = GetMessage(msg, 0, msg_filter_min=0, msg_filter_max=0)
+        res.should == 0
+      end
+
+      it "snake_case api returns a message struct retrieved from the calling thread's message queue " do
+        set_cursor_pos(x=99, y=99)
+        post_message(0, WM_USER+2, 33, nil)
+        msg = get_message()
+        should_have msg, hwnd: 0, message: WM_USER+2, w_param: 33, x: 99, y: 99, l_param: 0, time: 1000000
+      end
+
+      it "snake_case api returns nil if there is an error (wrong handle, in this case)" do
+        get_message(msg, not_a_handle).should == nil
+      end
+
+      it "snake_case api returns false if WM_QUIT was posted to thread`s message queue" do
+        post_message(0, WM_QUIT, 13, nil)
+        get_message.should == false
+      end
+    end # describe get_message
+
+
+    describe "#peek_message" do
+      before(:all){set_cursor_pos(x=0, y=0); post_message(0, WM_USER+2, 13, nil)}
+      spec{ use{ success = PeekMessage(msg, h_wnd=0, filter_min=0, filter_max=0, remove_msg=0) }}
+      spec{ use{ success = peek_message(msg, h_wnd=0, filter_min=0, filter_max=0, remove_msg=0) }}
+
+      it "original api checks the thread message queue for a posted message, retrieves it without removing" do
+        10.times do
+          res = PeekMessage(msg, h_wnd=0, filter_min=0, filter_max=0, remove_msg=0)
+          res.should == 1
+          should_have msg, hwnd: 0, message: WM_USER+2, w_param: 13, x: 0, y: 0, l_param: 0, time: 1000000
+        end
+      end
+
+      it "snake_case api checks the thread message queue for a posted message, returns it without removing" do
+        10.times do
+          msg = peek_message()
+          should_have msg, hwnd: 0, message: WM_USER+2, w_param: 13, x: 0, y: 0, l_param: 0, time: 1000000
+        end
+      end
+
+      it "original api returns 0 if no message in queue" do
+        get_message
+        PeekMessage(msg, h_wnd=0, filter_min=0, filter_max=0, remove_msg=0).should == 0
+      end
+
+      it "snake_case api returns nil if no message in queue" do
+        peek_message.should == nil
+      end
+    end # describe peek_message
+
+    describe "#translate_message" do
+      spec{ use{ success = TranslateMessage(msg) }}
+      spec{ use{ success = translate_message(msg) }}
+
+      it "translates virtual-key message into character message which is then posted to the thread's message queue"
+
+      it "returns zero/false if no translation took place" do
+        TranslateMessage(msg).should == 0
+        translate_message(msg).should == false
+      end
+    end # describe translate_message
+
+    describe "#dispatch_message" do
+      spec{ use{ res = DispatchMessage(msg) }} #return value is normally ignored
+      spec{ use{ res = dispatch_message(msg) }} #return value is normally ignored
+
+      it "dispatches a message to a window procedure. Typically used to dispatch a message retrieved by GetMessage" do
+        pending
+        res = DispatchMessage(msg)
+      end
+
+    end # describe dispatch_message
+
   end # Win::GUI::Message, ' defines a set of API functions related to Window messaging'
 end
 

data/win.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{win}
-  s.version = "0.1.18"
+  s.version = "0.1.22"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["arvicco"]
-  s.date = %q{2010-02-25}
+  s.date = %q{2010-03-06}
   s.description = %q{Rubyesque interfaces and wrappers for Windows API functions pre-defined using FFI }
   s.email = %q{arvitallian@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win
 version: !ruby/object:Gem::Version 
-  version: 0.1.18
+  version: 0.1.22
 platform: ruby
 authors: 
 - arvicco
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-25 00:00:00 +03:00
+date: 2010-03-06 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency