win 0.1.27 → 0.3.1

data/spec/spec.opts

@@ -1,2 +1,2 @@
---color
---format nested
+--color
+--format nested

data/spec/spec_helper.rb

@@ -1,136 +1,141 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'spec'
-require 'spec/autorun'
-require 'win/gui'
-
-$debug = true
-
-# Customize RSpec with my own extensions
-module ClassMacros
-
-  def os
-    `ver`
-  end
-
-  def vista?
-    os =~ /Version 6/
-  end
-
-  def xp?
-    os =~ /XP/
-  end
-
-  # wrapper for it method that extracts description from example source code, such as:
-  # spec { use{    function(arg1 = 4, arg2 = 'string')  }}
-  def spec &block
-    it description_from(caller[0]), &block # it description_from(*block.source_location), &block
-    #do lambda(&block).should_not raise_error end
-  end
-
-  # reads description line from source file and drops external brackets like its{}, use{}
-  # accepts as arguments either file name and line or call stack member (caller[0])
-  def description_from(*args)
-    case args.size
-      when 1
-        file, line = args.first.scan(/\A(.*?):(\d+)/).first
-      when 2
-        file, line = args
-    end
-    File.open(file) do |f|
-      f.lines.to_a[line.to_i-1].gsub( /(spec.*?{)|(use.*?{)|}/, '' ).strip
-    end
-  end
-end
-
-# Customize RSpec with my own extensions
-module InstanceMacros
-  def use
-    lambda{yield}.should_not raise_error
-  end
-
-  def any_block
-    lambda{|*args| args}
-  end
-end
-
-Spec::Runner.configure do |config|
-  config.extend(ClassMacros)
-  config.include(InstanceMacros)
-
-  class << Spec::ExampleGroup
-#    def spoc &block
-#      it description_from(caller[0]), &block
-#    end
-  end
-end
-
-module WinTest
-
-  TEST_KEY_DELAY = 0.001
-  TEST_IMPOSSIBLE = 'Impossible'
-  TEST_CONVERSION_ERROR = /Can.t convert/
-  TEST_SLEEP_DELAY = 0.02
-  TEST_APP_PATH = File.join(File.dirname(__FILE__), "test_apps/locknote/LockNote.exe" )
-  TEST_APP_START = 'start "" "' + TEST_APP_PATH + '"'
-  TEST_WIN_TITLE = 'LockNote - Steganos LockNote'
-  TEST_WIN_CLASS = 'ATL:00434098'
-  TEST_WIN_RECT = [710, 400, 1210, 800]
-  TEST_STATUSBAR_CLASS = 'msctls_statusbar32'
-  TEST_TEXTAREA_CLASS = 'ATL:00434310'
-
-  def any_handle
-    find_window(nil, nil)
-  end
-
-  def not_a_handle
-    123
-  end
-
-  def buffer
-    FFI::MemoryPointer.new(:char, 1024)
-  end
-end
-
-module WinTestApp
-
-  include WinTest
-  include Win::GUI
-  #include Win::GUI::Convenience
-
-  def launch_test_app
-    system TEST_APP_START
-    sleep TEST_SLEEP_DELAY until (handle = find_window(nil, TEST_WIN_TITLE))
-
-    textarea = find_window_ex(handle, 0, TEST_TEXTAREA_CLASS, nil)
-    app = "Locknote" # App identifier
-
-    eigenklass = class << app; self; end      # Extracting app's eigenclass
-    eigenklass.class_eval do                  # Defining singleton methods on app
-      define_method(:handle) {handle}
-      define_method(:textarea) {textarea}
-    end
-
-    @launched_test_app = app
-  end
-
-  def close_test_app(app = @launched_test_app)
-    while app && app.respond_to?( :handle) && find_window(nil, TEST_WIN_TITLE)
-      shut_window app.handle
-      sleep TEST_SLEEP_DELAY
-    end
-    @launched_test_app = nil
-  end
-
-  # Creates test app object and yields it back to the block
-  def test_app
-    app = launch_test_app
-
-#    def app.textarea #define singleton method retrieving app's text area
-#      Window::Window.new find_window_ex(self.handle, 0, TEST_TEXTAREA_CLASS, nil)
-#    end
-
-    yield app
-    close_test_app app
-  end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'spec'
+require 'spec/autorun'
+require 'win/gui'
+
+$debug = true
+
+# Customize RSpec with my own extensions
+module ClassMacros
+
+  # wrapper for it method that extracts description from example source code, such as:
+  # spec { use{    function(arg1 = 4, arg2 = 'string')  }}
+  def spec &block
+    it description_from(caller[0]), &block # it description_from(*block.source_location), &block
+    #do lambda(&block).should_not raise_error end
+  end
+
+  # reads description line from source file and drops external brackets like its{}, use{}
+  # accepts as arguments either file name and line or call stack member (caller[0])
+  def description_from(*args)
+    case args.size
+      when 1
+        file, line = args.first.scan(/\A(.*?):(\d+)/).first
+      when 2
+        file, line = args
+    end
+    File.open(file) do |f|
+      f.lines.to_a[line.to_i-1].gsub( /(spec.*?{)|(use.*?{)|}/, '' ).strip
+    end
+  end
+end
+
+# Customize RSpec with my own extensions
+module InstanceMacros
+  def use
+    lambda{yield}.should_not raise_error
+  end
+
+  def any_block
+    lambda{|*args| args}
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.extend(ClassMacros)
+  config.include(InstanceMacros)
+
+  class << Spec::ExampleGroup
+#    def spoc &block
+#      it description_from(caller[0]), &block
+#    end
+  end
+end
+
+# Global test methods
+def cygwin?
+  @cygwin_flag ||= `ruby -v` =~ /cygwin/
+end
+
+def os
+  @os_flag ||= cygwin? ? `cmd /c ver` : `ver`
+end
+
+def vista?
+  os =~ /Version 6/
+end
+
+def xp?
+  os =~ /XP/
+end
+
+module WinTest
+
+  TEST_KEY_DELAY = 0.001
+  TEST_IMPOSSIBLE = 'Impossible'
+  TEST_CONVERSION_ERROR = /Can.t convert/
+  TEST_SLEEP_DELAY = 0.02
+  TEST_APP_PATH = File.join(File.dirname(__FILE__), "test_apps/locknote/LockNote.exe" )
+  TEST_APP_START = cygwin? ? "cmd /c start `cygpath -w #{TEST_APP_PATH}`" : 'start "" "' + TEST_APP_PATH + '"'
+  TEST_WIN_TITLE = 'LockNote - Steganos LockNote'
+  TEST_WIN_CLASS = 'ATL:00434098'
+  TEST_WIN_RECT = [710, 400, 1210, 800]
+  TEST_STATUSBAR_CLASS = 'msctls_statusbar32'
+  TEST_TEXTAREA_CLASS = 'ATL:00434310'
+
+  def any_handle
+    find_window(nil, nil)
+  end
+
+  def not_a_handle
+    123
+  end
+
+  def buffer
+    FFI::MemoryPointer.new(:char, 1024)
+  end
+end
+
+module WinTestApp
+
+  include WinTest
+  include Win::Gui
+  #include Win::Gui::Convenience
+
+  def launch_test_app
+    system TEST_APP_START
+    sleep TEST_SLEEP_DELAY until (handle = find_window(nil, TEST_WIN_TITLE))
+
+    textarea = find_window_ex(handle, 0, TEST_TEXTAREA_CLASS, nil)
+    app = "Locknote" # App identifier
+
+    eigenklass = class << app; self; end      # Extracting app's eigenclass
+    eigenklass.class_eval do                  # Defining singleton methods on app
+      define_method(:handle) {handle}
+      define_method(:textarea) {textarea}
+    end
+
+    @launched_test_app = app
+  end
+
+  def close_test_app(app = @launched_test_app)
+    while app && app.respond_to?( :handle) && find_window(nil, TEST_WIN_TITLE)
+      shut_window app.handle
+      sleep TEST_SLEEP_DELAY
+    end
+    @launched_test_app = nil
+  end
+
+  # Creates test app object and yields it back to the block
+  def test_app
+    app = launch_test_app
+
+#    def app.textarea #define singleton method retrieving app's text area
+#      Window::Window.new find_window_ex(self.handle, 0, TEST_TEXTAREA_CLASS, nil)
+#    end
+
+    yield app
+    close_test_app app
+  end
 end

data/spec/win/dde_spec.rb

@@ -1,529 +1,529 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'win/dde'
-
-module WinDDETest
-  include WinTest
-  include Win::DDE
-  include Win::GUI::Message
-
-  POKE_STRING = "Poke_string"
-
-  def dde_cmd
-    APPCLASS_STANDARD
-  end
-
-  def dde_callback
-    ->(*args){}
-  end
-
-  def zero_id
-    FFI::MemoryPointer.new(:long).write_long(0)
-  end
-
-  def buffer
-    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
-
-  def setup_server(&server_block)
-    @client_calls = []
-    @server_calls = []
-    @client_id, st = dde_initialize(APPCLASS_STANDARD) {|*args| @client_calls << extract_values(*args); DDE_FACK}
-    @server_id, st = dde_initialize(APPCLASS_STANDARD,
-                                    &server_block || proc {|*args| @server_calls << extract_values(*args); DDE_FACK} )
-    @service_handle = dde_create_string_handle(@server_id, 'service 2', CP_WINANSI)
-    @topic_handle = dde_create_string_handle(@server_id, 'topic 2', CP_WINANSI)
-    dde_name_service(@server_id, @service_handle, DNS_REGISTER)
-  end
-
-  def teardown_server
-    if @print
-      p @server_calls, @client_calls
-      p @server_conv
-      p ERRORS[dde_get_last_error(@server_id)]
-      p ERRORS[dde_get_last_error(@client_id)]
-      @print = nil
-    end
-    dde_name_service(@server_id, @service_handle, DNS_UNREGISTER) if @server_id && @service_handle
-    dde_free_string_handle(@server_id, @service_handle) if @server_id && @service_handle
-    dde_free_string_handle(@server_id, @topic_handle) if @server_id && @topic_handle
-    dde_uninitialize(@server_id) if @server_id
-    dde_uninitialize(@client_id) if @client_id
-    if @conv_handle
-      dde_disconnect(@conv_handle)
-      @conv_handle = nil
-    end
-    @data = nil
-  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") }}
-      spec{ use{ register_clipboard_format(format_name = "XlTable") }}
-
-      it 'returns format id (int) if successfully registered format' do
-        id = register_clipboard_format("XlTable")
-        id.should_not == 0
-        id.should_not == nil
-      end
-
-      it 'returns same format id for already registered format' do
-        id1 = register_clipboard_format("XlTable")
-        id2 = register_clipboard_format("XlTable")
-        id1.should == id2
-      end
-
-      it 'returns nil if not able to register format' do
-        register_clipboard_format("").should == nil
-      end
-    end
-
-    describe '#dde_initialize' do
-      after(:each) {dde_uninitialize(@id) if @id}
-
-      spec{ use{ status = DdeInitialize( id = zero_id, dde_callback, dde_cmd, unused=0); @id = id.read_long}}
-      spec{ use{ @id, status = dde_initialize(@id=0, dde_cmd, &dde_callback) }}
-
-      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
-        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
-        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
-        status.should == DMLERR_NO_ERROR
-      end
-
-      it 'returns error status if initialization unsuccessful' do
-        @id, status = dde_initialize(12345, APPCLASS_STANDARD) {|*args| }
-        status.should == DMLERR_INVALIDPARAMETER
-        @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| }
-        status.should == DMLERR_NO_ERROR
-        new_id.should == @id
-      end
-    end # describe 'dde_initialize'
-
-    context 'after initialization:' do
-      before(:each) {@id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }}
-      after(:each) {dde_uninitialize(@id) if @id}
-
-      describe '#dde_uninitialize' do
-
-        spec{ use{ status = DdeUninitialize( @id ) }}
-        spec{ use{ id, status = dde_uninitialize( @id) }}
-
-        it 'returns true if uninitialization successful' do
-          res = dde_uninitialize(@id)
-          res.should == true
-        end
-
-        it 'returns false if initialization unsuccessful' do
-          res = dde_uninitialize(12345)
-          res.should == false
-        end
-      end # describe '#dde_uninitialize'
-
-      describe '#dde_create_string_handle' do
-        after(:each) {dde_free_string_handle(@id, @string_handle) if @string_handle}
-
-        spec{ use{ @string_handle = DdeCreateStringHandle(id=0, string_pointer, code_page_id=CP_WINANSI) }}
-        spec{ use{ @string_handle = dde_create_string_handle(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(@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(@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_handle = dde_create_string_handle(@id, 'My String')
-          10.times do
-            string_handle1 = dde_create_string_handle(@id, 'My String')
-            string_handle1.should == @string_handle
-            dde_free_string_handle(@id, string_handle1)
-          end
-        end
-
-        it 'created different handles for two different strings ' do
-          @string_handle = dde_create_string_handle(@id, 'My String')
-          string_handle1 = dde_create_string_handle(@id, 'My String1')
-          string_handle1.should_not == @string_handle
-          dde_free_string_handle(@id, string_handle1)
-        end
-
-        it 'returns nil if unable to register handle to a string' do
-          @string_handle = dde_create_string_handle(@id, "", CP_WINANSI)
-          @string_handle.should == nil
-        end
-      end # describe '#dde_create_string_handle'
-
-      context "with dde string handle to 'My String 2'" do
-        before(:each) {@string_handle = dde_create_string_handle(@id, 'My String 2', CP_WINANSI)}
-        after(:each) {dde_free_string_handle(@id, @string_handle)}
-
-        describe '#dde_query_string' do
-
-          spec{ use{ string = DdeQueryString(@id, @string_handle, buffer, buffer.size, code_page=CP_WINANSI)}}
-          spec{ use{ string = dde_query_string(@id, @string_handle, code_page=CP_WINANSI )}}
-
-          it 'retrieves string that given string handle refers to' do
-            num_chars = DdeQueryString(@id, @string_handle, buf = buffer, buf.size, CP_WINANSI)
-            num_chars.should == 11
-            buf.read_string.should == 'My String 2'
-          end
-
-          it 'retrieves string that given string handle refers to' do
-            string = dde_query_string(@id, @string_handle, CP_WINANSI)
-            string.should == 'My String 2'
-          end
-
-          it 'retrieves string even if code_page is omitted' do
-            string = dde_query_string(@id, @string_handle)
-            string.should == 'My String 2'
-          end
-
-          it 'returns nil attempting to retrieve invalid handle' do
-            string = dde_query_string(@id, 12345)
-            string.should == nil
-          end
-        end # describe '#dde_query_string'
-
-        describe '#dde_free_string_handle' do
-
-          spec{ use{ success = DdeFreeStringHandle( @id, @string_handle)}}
-          spec{ use{ success = dde_free_string_handle( @id, @string_handle )}}
-
-          it 'returns true when freeing string handle registered with DDEML' do
-            res = dde_free_string_handle(@id, @string_handle)
-            res.should == true
-          end
-
-          it 'returns false attempting to free unregistered handle' do
-            res = dde_free_string_handle(@id, 12345)
-            res.should == false
-          end
-
-          it 'keeps string accessible while references to it still exist' do
-            # creates second handle to 'My String 2'
-            string_handle_1 = dde_create_string_handle(@id, 'My String 2', CP_WINANSI)
-
-            dde_free_string_handle(@id, @string_handle)
-            dde_query_string(@id, @string_handle).should == 'My String 2'
-
-            dde_free_string_handle(@id, string_handle_1)
-            dde_query_string(@id, @string_handle).should == nil
-          end
-
-          it 'makes string inaccessible once its last handle is freed' do
-            dde_free_string_handle(@id, @string_handle)
-            dde_query_string(@id, @string_handle).should == nil
-          end
-        end # describe '#dde_free_string_handle'
-
-        describe '#dde_get_last_error' do
-          spec{ use{ error_code = DdeGetLastError(@id) }}
-          spec{ use{ error_code = dde_get_last_error(@id) }}
-
-          it 'original API returns DMLERR_NO_ERROR if there is no last DDE error for given app instance' do
-            DdeGetLastError(@id).should == DMLERR_NO_ERROR
-          end
-
-          it 'snake_case API returns nil if there is no last DDE error for given app instance' do
-            dde_get_last_error(@id).should == nil
-          end
-
-          it 'returns error code of last DDE error for given app instance' do
-            dde_name_service(@id, 1234, DNS_REGISTER )
-            dde_get_last_error(@id).should == DMLERR_INVALIDPARAMETER
-          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){ setup_server }
-      after(:each) { teardown_server}
-
-      describe '#dde_name_service' do
-        spec{ use{ success = dde_name_service(@server_id, @service_handle, cmd=DNS_UNREGISTER ) }}
-        spec{ use{ success = DdeNameService(@server_id, @service_handle, reserved=0, cmd=DNS_UNREGISTER) }}
-
-        it 'registers or unregisters the service names that DDE server supports' do
-          pending 'Register/Unregister messages don`t show up in @server_calls :('
-          success = dde_name_service(@server_id, @service_handle, DNS_REGISTER )
-          success.should == true
-          success = dde_name_service(@server_id, @service_handle, DNS_UNREGISTER )
-          success.should == true
-        end
-      end # describe '#dde_name_service'
-
-      describe '#dde_connect' do
-        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
-        end
-
-        it 'connects to existing DDE server (from @client, 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
-        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 (self) DDE server' do
-          conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-          dde_disconnect(conv_handle).should == true
-        end
-
-        it 'disconnects from existing (self) DDE server' do
-          pending 'XTYP_DISCONNECT is not received by server callback (since we are disconnecting from self?)'
-          conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-          dde_disconnect(conv_handle).should == true
-          @server_calls.last[0].should == "XTYP_DISCONNECT"
-          p @server_calls, @client_calls, @server_conv
-          p ERRORS[dde_get_last_error(@server_id)]
-          p ERRORS[dde_get_last_error(@client_id)]
-        end
-      end # describe '#dde_disconnect'
-    end # context 'with synthetic DDE server'
-
-    describe "#dde_client_transaction" do
-      before(:each) do
-        setup_server do |*args|
-          @server_calls << extract_values(*args)
-          @data_out, size = dde_get_data(args[5]) if args.first == XTYP_POKE || args.first == XTYP_EXECUTE
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        @data_in = FFI::MemoryPointer.from_string POKE_STRING
-      end
-      after(:each) { teardown_server}
-
-      spec{ use{ DdeClientTransaction(data=nil, size=0, conv=0, item=0, format=0, type=0, timeout=0, result=nil) }}
-      spec{ use{ dde_client_transaction(data=nil, size=0, conv=0, item=0, format=0, type=0, timeout=0, result=nil) }}
-
-
-      it "returns 0/nil if initiated transaction unsuccessful" do
-        res = DdeClientTransaction(@data_in, @data_in.size, 1234, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-        res.should == 0     # wrong conversation handle
-        res = dde_client_transaction(@data_in, @data_in.size, 1234, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-        res.should == nil   # wrong conversation handle
-        res = dde_client_transaction(@data_in, @data_in.size, @conv_handle, 0, CF_TEXT, XTYP_POKE, 1000, nil)
-        res.should == nil   # wrong item handle (cannot be NULL in XTYP_POKE transaction)
-        @server_calls.any? {|call| call[0] == 'XTYP_POKE'}.should be_false
-      end
-
-      it "original api is used by CLIENT to begins a data transaction with server" do
-        res = DdeClientTransaction(@data_in, @data_in.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-        res.should == 1
-        @server_calls.any? {|call| call[0] == 'XTYP_POKE'}.should be_true
-        @data_out.read_string.should == POKE_STRING.rstrip
-      end
-
-      it "snake_case api begins a data transaction between a client and a server" do
-        res = dde_client_transaction(@data_in, @data_in.size, @conv_handle, 0, 0, XTYP_EXECUTE, 1000, nil)
-        res.should be_true
-        @server_calls.any? {|call| call[0] == 'XTYP_EXECUTE'}.should be_true
-        @data_out.read_string.should == POKE_STRING.rstrip
-      end
-    end # describe dde_client_transaction
-
-    describe '#dde_get_data' do
-      after(:each) { teardown_server}
-
-      spec{ use{ data_pointer, size = dde_get_data( data_handle = 123, max = 1073741823, offset = 0) }}
-      spec{ use{ size = DdeGetData( data_handle = 123, nil, 0, 0) }} # returns dde data set size in bytes
-      spec{ use{ size = DdeGetData( data_handle = 123, FFI::MemoryPointer.new(:char, 1024), max = 1024, offset = 0) }}
-
-      it 'original API returns 0 if trying to address invalid dde data handle' do
-        DdeGetData( data_handle = 123, nil, 0, 0).should == 0
-      end
-
-      it 'snake_case API returns [nil, 0] if trying to address invalid dde data handle' do
-        data, size = dde_get_data( data_handle = 123, 3741823, 0)
-        data.should == nil
-      end
-
-      it 'returns dde data if used inside dde callback block' do
-        setup_server do |*args|
-          @server_calls << extract_values(*args);
-          if args[0] == XTYP_POKE
-            data_handle = args[5]
-            data, size = dde_get_data(data_handle)
-            data.should be_an FFI::MemoryPointer
-            data.read_string.should == POKE_STRING.rstrip
-            size.should == 12
-            DdeGetData(data_handle, nil, 0, 0).should == 12
-            data = FFI::MemoryPointer.new(:char, 1024)
-            DdeGetData(data_handle, data, data.size, 0).should == 12
-            data.read_string.should == POKE_STRING.rstrip
-          end
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        str = FFI::MemoryPointer.from_string POKE_STRING
-        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-      end
-
-      it 'dde data handle expires once transaction is finished (DDE_FACK)' do
-        setup_server do |*args|
-          @server_calls << extract_values(*args);
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        str = FFI::MemoryPointer.from_string POKE_STRING
-        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-
-        # only inside callback block dde data handle is valid (while transaction still in progress)
-        data, size = dde_get_data(@server_calls.last[5])
-        data.should == nil
-        size.should == 0
-      end
-
-    end # describe '#dde_get_data'
-
-    describe "#dde_access_data" do
-      after(:each) { teardown_server}
-
-      spec{ use{ success = DdeAccessData(data_handle = 123, data_size=zero_id) }}
-      spec{ use{ data_pointer, size = dde_access_data(data_handle = 123) }}
-
-      it "provides access to the data in the specified DDE data handle (both inside and outside of callback)" do
-        setup_server do |*args|
-          @server_calls << extract_values(*args)
-          if args[0] == XTYP_POKE
-            data_handle = args[5]
-            data, size = dde_access_data(data_handle)
-            data.should be_kind_of FFI::Pointer
-            data.read_string.should == POKE_STRING.rstrip
-            size.should == 12
-            buf = FFI::MemoryPointer.new(:int16)
-            data = DdeAccessData(data_handle, buf)
-            buf.get_int16(0).should == 12
-            data.should be_kind_of FFI::Pointer
-            data.read_string.should == POKE_STRING.rstrip
-            dde_unaccess_data(data_handle)
-          end
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        str = FFI::MemoryPointer.from_string POKE_STRING
-        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-      end
-
-      it 'dde data handle expires once transaction is finished (DDE_FACK)' do
-        setup_server do |*args|
-          @server_calls << extract_values(*args);
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        str = FFI::MemoryPointer.from_string POKE_STRING
-        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-
-        # only inside callback block dde data handle is valid (while transaction still in progress)
-        data, size = dde_access_data(@server_calls.last[5])
-        data.should == nil
-        size.should == 0
-      end
-    end # describe dde_access_data
-
-    describe "#dde_unaccess_data" do
-      spec{ use{ success = DdeUnaccessData(data_handle = 123) }}
-      spec{ use{ success = dde_unaccess_data(data_handle = 123) }}
-
-      it "returns 0/false if given invalid DDE data handle " do
-        DdeUnaccessData(data_handle = 123).should == 0
-        dde_unaccess_data(data_handle = 123).should == false
-      end
-
-      it "unaccesses a DDE data handle that was previously accessed" do
-        setup_server do |*args|
-          @server_calls << extract_values(*args);
-          if args[0] == XTYP_POKE
-            data_handle = args[5]
-            dde_unaccess_data(data_handle).should == true
-
-            data, size = dde_access_data(data_handle)
-            data.should be_kind_of FFI::Pointer
-            data.read_string.should == POKE_STRING.rstrip
-
-            dde_unaccess_data(data_handle).should == true
-          end
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        str = FFI::MemoryPointer.from_string POKE_STRING
-        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-      end
-
-      it 'dde data handle expires once transaction is finished (DDE_FACK)' do
-        setup_server do |*args|
-          @server_calls << extract_values(*args);
-          DDE_FACK
-        end
-        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
-        str = FFI::MemoryPointer.from_string POKE_STRING
-        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
-
-        # only inside callback block dde data handle is valid (while transaction still in progress)
-        dde_unaccess_data(@server_calls.last[5]).should == false
-      end
-
-    end # describe dde_unaccess_data
-  end
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'win/dde'
+
+module WinDdeTest
+  include WinTest
+  include Win::Dde
+  include Win::Gui::Message
+
+  POKE_STRING = "Poke_string"
+
+  def dde_cmd
+    APPCLASS_STANDARD
+  end
+
+  def dde_callback
+    ->(*args){}
+  end
+
+  def zero_id
+    FFI::MemoryPointer.new(:long).write_long(0)
+  end
+
+  def buffer
+    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
+
+  def setup_server(&server_block)
+    @client_calls = []
+    @server_calls = []
+    @client_id, st = dde_initialize(APPCLASS_STANDARD) {|*args| @client_calls << extract_values(*args); DDE_FACK}
+    @server_id, st = dde_initialize(APPCLASS_STANDARD,
+                                    &server_block || proc {|*args| @server_calls << extract_values(*args); DDE_FACK} )
+    @service_handle = dde_create_string_handle(@server_id, 'service 2', CP_WINANSI)
+    @topic_handle = dde_create_string_handle(@server_id, 'topic 2', CP_WINANSI)
+    dde_name_service(@server_id, @service_handle, DNS_REGISTER)
+  end
+
+  def teardown_server
+    if @print
+      p @server_calls, @client_calls
+      p @server_conv
+      p ERRORS[dde_get_last_error(@server_id)]
+      p ERRORS[dde_get_last_error(@client_id)]
+      @print = nil
+    end
+    dde_name_service(@server_id, @service_handle, DNS_UNREGISTER) if @server_id && @service_handle
+    dde_free_string_handle(@server_id, @service_handle) if @server_id && @service_handle
+    dde_free_string_handle(@server_id, @topic_handle) if @server_id && @topic_handle
+    dde_uninitialize(@server_id) if @server_id
+    dde_uninitialize(@client_id) if @client_id
+    if @conv_handle
+      dde_disconnect(@conv_handle)
+      @conv_handle = nil
+    end
+    @data = nil
+  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") }}
+      spec{ use{ register_clipboard_format(format_name = "XlTable") }}
+
+      it 'returns format id (int) if successfully registered format' do
+        id = register_clipboard_format("XlTable")
+        id.should_not == 0
+        id.should_not == nil
+      end
+
+      it 'returns same format id for already registered format' do
+        id1 = register_clipboard_format("XlTable")
+        id2 = register_clipboard_format("XlTable")
+        id1.should == id2
+      end
+
+      it 'returns nil if not able to register format' do
+        register_clipboard_format("").should == nil
+      end
+    end
+
+    describe '#dde_initialize' do
+      after(:each) {dde_uninitialize(@id) if @id}
+
+      spec{ use{ status = DdeInitialize( id = zero_id, dde_callback, dde_cmd, unused=0); @id = id.read_long}}
+      spec{ use{ @id, status = dde_initialize(@id=0, dde_cmd, &dde_callback) }}
+
+      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
+        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
+        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
+        status.should == DMLERR_NO_ERROR
+      end
+
+      it 'returns error status if initialization unsuccessful' do
+        @id, status = dde_initialize(12345, APPCLASS_STANDARD) {|*args| }
+        status.should == DMLERR_INVALIDPARAMETER
+        @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| }
+        status.should == DMLERR_NO_ERROR
+        new_id.should == @id
+      end
+    end # describe 'dde_initialize'
+
+    context 'after initialization:' do
+      before(:each) {@id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }}
+      after(:each) {dde_uninitialize(@id) if @id}
+
+      describe '#dde_uninitialize' do
+
+        spec{ use{ status = DdeUninitialize( @id ) }}
+        spec{ use{ id, status = dde_uninitialize( @id) }}
+
+        it 'returns true if uninitialization successful' do
+          res = dde_uninitialize(@id)
+          res.should == true
+        end
+
+        it 'returns false if initialization unsuccessful' do
+          res = dde_uninitialize(12345)
+          res.should == false
+        end
+      end # describe '#dde_uninitialize'
+
+      describe '#dde_create_string_handle' do
+        after(:each) {dde_free_string_handle(@id, @string_handle) if @string_handle}
+
+        spec{ use{ @string_handle = DdeCreateStringHandle(id=0, string_pointer, code_page_id=CP_WINANSI) }}
+        spec{ use{ @string_handle = dde_create_string_handle(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(@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(@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_handle = dde_create_string_handle(@id, 'My String')
+          10.times do
+            string_handle1 = dde_create_string_handle(@id, 'My String')
+            string_handle1.should == @string_handle
+            dde_free_string_handle(@id, string_handle1)
+          end
+        end
+
+        it 'created different handles for two different strings ' do
+          @string_handle = dde_create_string_handle(@id, 'My String')
+          string_handle1 = dde_create_string_handle(@id, 'My String1')
+          string_handle1.should_not == @string_handle
+          dde_free_string_handle(@id, string_handle1)
+        end
+
+        it 'returns nil if unable to register handle to a string' do
+          @string_handle = dde_create_string_handle(@id, "", CP_WINANSI)
+          @string_handle.should == nil
+        end
+      end # describe '#dde_create_string_handle'
+
+      context "with dde string handle to 'My String 2'" do
+        before(:each) {@string_handle = dde_create_string_handle(@id, 'My String 2', CP_WINANSI)}
+        after(:each) {dde_free_string_handle(@id, @string_handle)}
+
+        describe '#dde_query_string' do
+
+          spec{ use{ string = DdeQueryString(@id, @string_handle, buffer, buffer.size, code_page=CP_WINANSI)}}
+          spec{ use{ string = dde_query_string(@id, @string_handle, code_page=CP_WINANSI )}}
+
+          it 'retrieves string that given string handle refers to' do
+            num_chars = DdeQueryString(@id, @string_handle, buf = buffer, buf.size, CP_WINANSI)
+            num_chars.should == 11
+            buf.read_string.should == 'My String 2'
+          end
+
+          it 'retrieves string that given string handle refers to' do
+            string = dde_query_string(@id, @string_handle, CP_WINANSI)
+            string.should == 'My String 2'
+          end
+
+          it 'retrieves string even if code_page is omitted' do
+            string = dde_query_string(@id, @string_handle)
+            string.should == 'My String 2'
+          end
+
+          it 'returns nil attempting to retrieve invalid handle' do
+            string = dde_query_string(@id, 12345)
+            string.should == nil
+          end
+        end # describe '#dde_query_string'
+
+        describe '#dde_free_string_handle' do
+
+          spec{ use{ success = DdeFreeStringHandle( @id, @string_handle)}}
+          spec{ use{ success = dde_free_string_handle( @id, @string_handle )}}
+
+          it 'returns true when freeing string handle registered with DDEML' do
+            res = dde_free_string_handle(@id, @string_handle)
+            res.should == true
+          end
+
+          it 'returns false attempting to free unregistered handle' do
+            res = dde_free_string_handle(@id, 12345)
+            res.should == false
+          end
+
+          it 'keeps string accessible while references to it still exist' do
+            # creates second handle to 'My String 2'
+            string_handle_1 = dde_create_string_handle(@id, 'My String 2', CP_WINANSI)
+
+            dde_free_string_handle(@id, @string_handle)
+            dde_query_string(@id, @string_handle).should == 'My String 2'
+
+            dde_free_string_handle(@id, string_handle_1)
+            dde_query_string(@id, @string_handle).should == nil
+          end
+
+          it 'makes string inaccessible once its last handle is freed' do
+            dde_free_string_handle(@id, @string_handle)
+            dde_query_string(@id, @string_handle).should == nil
+          end
+        end # describe '#dde_free_string_handle'
+
+        describe '#dde_get_last_error' do
+          spec{ use{ error_code = DdeGetLastError(@id) }}
+          spec{ use{ error_code = dde_get_last_error(@id) }}
+
+          it 'original API returns DMLERR_NO_ERROR if there is no last DDE error for given app instance' do
+            DdeGetLastError(@id).should == DMLERR_NO_ERROR
+          end
+
+          it 'snake_case API returns nil if there is no last DDE error for given app instance' do
+            dde_get_last_error(@id).should == nil
+          end
+
+          it 'returns error code of last DDE error for given app instance' do
+            dde_name_service(@id, 1234, DNS_REGISTER )
+            dde_get_last_error(@id).should == DMLERR_INVALIDPARAMETER
+          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){ setup_server }
+      after(:each) { teardown_server}
+
+      describe '#dde_name_service' do
+        spec{ use{ success = dde_name_service(@server_id, @service_handle, cmd=DNS_UNREGISTER ) }}
+        spec{ use{ success = DdeNameService(@server_id, @service_handle, reserved=0, cmd=DNS_UNREGISTER) }}
+
+        it 'registers or unregisters the service names that DDE server supports' do
+          pending 'Register/Unregister messages don`t show up in @server_calls :('
+          success = dde_name_service(@server_id, @service_handle, DNS_REGISTER )
+          success.should == true
+          success = dde_name_service(@server_id, @service_handle, DNS_UNREGISTER )
+          success.should == true
+        end
+      end # describe '#dde_name_service'
+
+      describe '#dde_connect' do
+        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
+        end
+
+        it 'connects to existing DDE server (from @client, 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
+        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 (self) DDE server' do
+          conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+          dde_disconnect(conv_handle).should == true
+        end
+
+        it 'disconnects from existing (self) DDE server' do
+          pending 'XTYP_DISCONNECT is not received by server callback (since we are disconnecting from self?)'
+          conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+          dde_disconnect(conv_handle).should == true
+          @server_calls.last[0].should == "XTYP_DISCONNECT"
+          p @server_calls, @client_calls, @server_conv
+          p ERRORS[dde_get_last_error(@server_id)]
+          p ERRORS[dde_get_last_error(@client_id)]
+        end
+      end # describe '#dde_disconnect'
+    end # context 'with synthetic DDE server'
+
+    describe "#dde_client_transaction" do
+      before(:each) do
+        setup_server do |*args|
+          @server_calls << extract_values(*args)
+          @data_out, size = dde_get_data(args[5]) if args.first == XTYP_POKE || args.first == XTYP_EXECUTE
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        @data_in = FFI::MemoryPointer.from_string POKE_STRING
+      end
+      after(:each) { teardown_server}
+
+      spec{ use{ DdeClientTransaction(data=nil, size=0, conv=0, item=0, format=0, type=0, timeout=0, result=nil) }}
+      spec{ use{ dde_client_transaction(data=nil, size=0, conv=0, item=0, format=0, type=0, timeout=0, result=nil) }}
+
+
+      it "returns 0/nil if initiated transaction unsuccessful" do
+        res = DdeClientTransaction(@data_in, @data_in.size, 1234, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+        res.should == 0     # wrong conversation handle
+        res = dde_client_transaction(@data_in, @data_in.size, 1234, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+        res.should == nil   # wrong conversation handle
+        res = dde_client_transaction(@data_in, @data_in.size, @conv_handle, 0, CF_TEXT, XTYP_POKE, 1000, nil)
+        res.should == nil   # wrong item handle (cannot be NULL in XTYP_POKE transaction)
+        @server_calls.any? {|call| call[0] == 'XTYP_POKE'}.should be_false
+      end
+
+      it "original api is used by CLIENT to begins a data transaction with server" do
+        res = DdeClientTransaction(@data_in, @data_in.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+        res.should == 1
+        @server_calls.any? {|call| call[0] == 'XTYP_POKE'}.should be_true
+        @data_out.read_string.should == POKE_STRING.rstrip
+      end
+
+      it "snake_case api begins a data transaction between a client and a server" do
+        res = dde_client_transaction(@data_in, @data_in.size, @conv_handle, 0, 0, XTYP_EXECUTE, 1000, nil)
+        res.should be_true
+        @server_calls.any? {|call| call[0] == 'XTYP_EXECUTE'}.should be_true
+        @data_out.read_string.should == POKE_STRING.rstrip
+      end
+    end # describe dde_client_transaction
+
+    describe '#dde_get_data' do
+      after(:each) { teardown_server}
+
+      spec{ use{ data_pointer, size = dde_get_data( data_handle = 123, max = 1073741823, offset = 0) }}
+      spec{ use{ size = DdeGetData( data_handle = 123, nil, 0, 0) }} # returns dde data set size in bytes
+      spec{ use{ size = DdeGetData( data_handle = 123, FFI::MemoryPointer.new(:char, 1024), max = 1024, offset = 0) }}
+
+      it 'original API returns 0 if trying to address invalid dde data handle' do
+        DdeGetData( data_handle = 123, nil, 0, 0).should == 0
+      end
+
+      it 'snake_case API returns [nil, 0] if trying to address invalid dde data handle' do
+        data, size = dde_get_data( data_handle = 123, 3741823, 0)
+        data.should == nil
+      end
+
+      it 'returns dde data if used inside dde callback block' do
+        setup_server do |*args|
+          @server_calls << extract_values(*args);
+          if args[0] == XTYP_POKE
+            data_handle = args[5]
+            data, size = dde_get_data(data_handle)
+            data.should be_an FFI::MemoryPointer
+            data.read_string.should == POKE_STRING.rstrip
+            size.should == 12
+            DdeGetData(data_handle, nil, 0, 0).should == 12
+            data = FFI::MemoryPointer.new(:char, 1024)
+            DdeGetData(data_handle, data, data.size, 0).should == 12
+            data.read_string.should == POKE_STRING.rstrip
+          end
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        str = FFI::MemoryPointer.from_string POKE_STRING
+        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+      end
+
+      it 'dde data handle expires once transaction is finished (DDE_FACK)' do
+        setup_server do |*args|
+          @server_calls << extract_values(*args);
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        str = FFI::MemoryPointer.from_string POKE_STRING
+        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+
+        # only inside callback block dde data handle is valid (while transaction still in progress)
+        data, size = dde_get_data(@server_calls.last[5])
+        data.should == nil
+        size.should == 0
+      end
+
+    end # describe '#dde_get_data'
+
+    describe "#dde_access_data" do
+      after(:each) { teardown_server}
+
+      spec{ use{ success = DdeAccessData(data_handle = 123, data_size=zero_id) }}
+      spec{ use{ data_pointer, size = dde_access_data(data_handle = 123) }}
+
+      it "provides access to the data in the specified DDE data handle (both inside and outside of callback)" do
+        setup_server do |*args|
+          @server_calls << extract_values(*args)
+          if args[0] == XTYP_POKE
+            data_handle = args[5]
+            data, size = dde_access_data(data_handle)
+            data.should be_kind_of FFI::Pointer
+            data.read_string.should == POKE_STRING.rstrip
+            size.should == 12
+            buf = FFI::MemoryPointer.new(:int16)
+            data = DdeAccessData(data_handle, buf)
+            buf.get_int16(0).should == 12
+            data.should be_kind_of FFI::Pointer
+            data.read_string.should == POKE_STRING.rstrip
+            dde_unaccess_data(data_handle)
+          end
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        str = FFI::MemoryPointer.from_string POKE_STRING
+        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+      end
+
+      it 'dde data handle expires once transaction is finished (DDE_FACK)' do
+        setup_server do |*args|
+          @server_calls << extract_values(*args);
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        str = FFI::MemoryPointer.from_string POKE_STRING
+        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+
+        # only inside callback block dde data handle is valid (while transaction still in progress)
+        data, size = dde_access_data(@server_calls.last[5])
+        data.should == nil
+        size.should == 0
+      end
+    end # describe dde_access_data
+
+    describe "#dde_unaccess_data" do
+      spec{ use{ success = DdeUnaccessData(data_handle = 123) }}
+      spec{ use{ success = dde_unaccess_data(data_handle = 123) }}
+
+      it "returns 0/false if given invalid DDE data handle " do
+        DdeUnaccessData(data_handle = 123).should == 0
+        dde_unaccess_data(data_handle = 123).should == false
+      end
+
+      it "unaccesses a DDE data handle that was previously accessed" do
+        setup_server do |*args|
+          @server_calls << extract_values(*args);
+          if args[0] == XTYP_POKE
+            data_handle = args[5]
+            dde_unaccess_data(data_handle).should == true
+
+            data, size = dde_access_data(data_handle)
+            data.should be_kind_of FFI::Pointer
+            data.read_string.should == POKE_STRING.rstrip
+
+            dde_unaccess_data(data_handle).should == true
+          end
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        str = FFI::MemoryPointer.from_string POKE_STRING
+        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+      end
+
+      it 'dde data handle expires once transaction is finished (DDE_FACK)' do
+        setup_server do |*args|
+          @server_calls << extract_values(*args);
+          DDE_FACK
+        end
+        @conv_handle = dde_connect( @server_id, @service_handle, @topic_handle, context=nil)
+        str = FFI::MemoryPointer.from_string POKE_STRING
+        dde_client_transaction(str, str.size, @conv_handle, @topic_handle, CF_TEXT, XTYP_POKE, 1000, nil)
+
+        # only inside callback block dde data handle is valid (while transaction still in progress)
+        dde_unaccess_data(@server_calls.last[5]).should == false
+      end
+
+    end # describe dde_unaccess_data
+  end
 end