win 0.3.24 → 0.3.25

data/lib/win/time.rb

@@ -0,0 +1,140 @@
+require 'win/library'
+
+module Win
+
+  # Includes functions related to Time in Windows
+  # In general you will want to use this module with Win::National because
+  # it contains the various LOCALE and TIME constants.
+  #
+  # *NB*: Millisecond granularity may NOT be supported by a hardware platform.
+  # The caller of these functions should not rely on more than second granularity.
+  # In fact, granularity of all the GetTime... functions is about ~16msec on Windows.
+  # You'll need to mess with QueryPerformanceFrequency() and QueryPerformanceCounter()
+  # to get real msec granularity on MS Windows;
+  #
+  module Time
+    extend Win::Library
+    TIME_ZONE_ID_UNKNOWN  = 0
+    TIME_ZONE_ID_STANDARD = 1
+    TIME_ZONE_ID_DAYLIGHT = 2
+
+
+    ##
+    # QueryPerformanceFrequency Function
+    # Retrieves the frequency of the high-resolution performance counter, if one exists.
+    # The frequency cannot change while the system is running.
+    #
+    # [*Syntax*] BOOL WINAPI QueryPerformanceFrequency( lpFrequency );
+    #
+    # lpFrequency <out>
+    # Type: LARGE_INTEGER*
+    # A pointer to a variable that receives the current performance-counter frequency,
+    # in counts per second. If the installed hardware does not support a high-resolution
+    # performance counter, this parameter can be zero.
+    #
+    # *Returns*:: Type: BOOL
+    # If the installed hardware supports a high-resolution performance counter, the return
+    # value is nonzero. If the function fails, the return value is zero. To get extended
+    # error information, call GetLastError. For example, if the installed hardware does
+    # not support a high-resolution performance counter, the function fails.
+    #
+    # ---
+    # <b>Enhanced (snake_case) API: returns high-resolution performance counter frequency
+    # or nil if no high-resolution performance counter is available</b>
+    #
+    # :call-seq:
+    #  frequency = query_performance_frequency()
+    #
+    function :QueryPerformanceFrequency, [:pointer], :int8,
+             &->(api){
+             freq = FFI::MemoryPointer.new(:int64)
+             api.call(freq) == 0 ? nil : freq.get_int64(0) }
+
+    ##
+    # QueryPerformanceCounter Function
+    # Retrieves the current value of the high-resolution performance counter.
+    #
+    # [*Syntax*] BOOL WINAPI QueryPerformanceCounter( __out  LARGE_INTEGER *lpPerformanceCount );
+    #
+    # lpPerformanceCount <out>
+    # Type: LARGE_INTEGER*
+    # A pointer to a variable that receives the current performance-counter value, in counts.
+    #
+    # *Returns*:: Type: BOOL
+    # If the function succeeds, the return value is nonzero.
+    # If the function fails, the return value is zero. To get extended error information,
+    # call GetLastError.
+    # ---
+    # *Remarks*:
+    # On a multiprocessor computer, it should not matter which processor is called. However,
+    # you can get different results on different processors due to bugs in the basic
+    # input/output system (BIOS) or the hardware abstraction layer (HAL). To specify
+    # processor affinity for a thread, use the SetThreadAffinityMask function.
+    # ---
+    # <b>Enhanced (snake_case) API: returns current performance counter value, in counts.
+    # Returns nil if function fails</b>
+    #
+    # :call-seq:
+    #  counter = query_performance_counter()
+    #
+    function :QueryPerformanceCounter, [:pointer], :int8,
+             &->(api){
+             count = FFI::MemoryPointer.new(:int64)
+             api.call(count) == 0 ? nil : count.get_int64(0) }
+
+    # Untested
+
+    ##
+    function :CompareFileTime, 'PP', 'L'
+    ##
+    function :DosDateTimeToFileTime, 'IIP', :int8, boolean: true
+    ##
+    function :FileTimeToDosDateTime, 'PPP', :int8, boolean: true
+    ##
+    function :FileTimeToLocalFileTime, 'PP', :int8, boolean: true
+    ##
+    function :FileTimeToSystemTime, 'PP', :int8, boolean: true
+    ##
+    function :GetFileTime, 'LPPP', :int8, boolean: true
+    ##
+    # [out] Pointer to a SYSTEMTIME structure to receive the current local date and time.
+    function :GetLocalTime, 'P', :void
+    ##
+    # This function retrieves the current system date and time. The system time is expressed in UTC.
+    #    [out] Pointer to a SYSTEMTIME structure to receive the current system date and time.
+    function :GetSystemTime, 'P', :void
+    ##
+    function :GetSystemTimeAdjustment, 'PPP', :int8, boolean: true
+    ##
+    function :GetSystemTimeAsFileTime, 'P', :void
+    ##
+    function :GetTickCount, [], :void
+    ##
+    function :GetTimeFormat, 'ILPPPI', 'I'
+    ##
+    function :GetTimeZoneInformation, 'P', 'L'
+    ##
+    function :LocalFileTimeToFileTime, 'PP', :int8, boolean: true
+    ##
+    function :SetFileTime, 'LPPP', :int8, boolean: true
+    ##
+    function :SetLocalTime, 'P', :int8, boolean: true
+    ##
+    function :SetSystemTime, 'P', :int8, boolean: true
+    ##
+    function :SetTimeZoneInformation, 'P', :int8, boolean: true
+    ##
+    function :SetSystemTimeAdjustment, 'LI', :int8, boolean: true
+    ##
+    function :SystemTimeToFileTime, 'PP', :int8, boolean: true
+    ##
+    function :SystemTimeToTzSpecificLocalTime, 'PPP', :int8, boolean: true
+
+    ##
+    try_function :GetSystemTimes, 'PPP', :int8, boolean: true
+    ##
+    try_function :TzSpecificLocalTimeToSystemTime, 'PPP', :int8, boolean: true
+
+
+  end
+end

data/spec/extension_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), "spec_helper" )
+require 'spec_helper'
 require 'extension'
 
 module WinTest
@@ -8,7 +8,7 @@ module WinTest
       it 'transforms CamelCase strings' do
         'GetCharWidth32'.snake_case.should == 'get_char_width_32'
       end
-      
+
       it 'leaves snake_case strings intact' do
         'keybd_event'.snake_case.should == 'keybd_event'
       end
@@ -33,41 +33,5 @@ module WinTest
         'GetCharWidth32'.to_w.bytes.to_a[-2..-1].should == [0, 0]
       end
     end
-
-#    context '#to_vkeys' do
-#      it 'transforms number char into [equivalent key code]' do
-#       ('0'..'9').each {|char| char.to_vkeys.should == char.unpack('C')}
-#      end
-#
-#      it 'transforms uppercase letters into [shift, equivalent key code]' do
-#       ('A'..'Z').each {|char| char.to_vkeys.should == [0x10, *char.unpack('C')]}
-#        # Win.const_get(:VK_SHIFT) = 0x10 Bad coupling
-#      end
-#
-#      it 'transforms lowercase letters into [(upcase) key code]' do
-#       ('a'..'z').each {|char| char.to_vkeys.should == char.upcase.unpack('C')}
-#      end
-#
-#      it 'transforms space into [equivalent key code]' do
-#        " ".to_vkeys.should == " ".unpack('C')
-#      end
-#
-#      it 'raises error if char is not implemented punctuation' do
-#       ('!'..'/').each {|char| lambda {char.to_vkeys}.should raise_error CONVERSION_ERROR }
-#       (':'..'@').each {|char| lambda {char.to_vkeys}.should raise_error CONVERSION_ERROR }
-#       ('['..'`').each {|char| lambda {char.to_vkeys}.should raise_error CONVERSION_ERROR }
-#       ('{'..'~').each {|char| lambda {char.to_vkeys}.should raise_error CONVERSION_ERROR }
-#      end
-#
-#      it 'raises error if char is non-printable or non-ascii' do
-#        lambda {1.chr.to_vkeys}.should raise_error CONVERSION_ERROR
-#        lambda {230.chr.to_vkeys}.should raise_error CONVERSION_ERROR
-#      end
-#
-#      it 'raises error if string is multi-char' do
-#        lambda {'hello'.to_vkeys}.should raise_error CONVERSION_ERROR
-#        lambda {'23'.to_vkeys}.should raise_error CONVERSION_ERROR
-#      end
-#    end
   end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,35 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'spec'
-require 'spec/autorun'
+require 'bundler'
+Bundler.setup
+Bundler.require :test
 require 'win/gui'
 
 $debug = false
 
+# Global test methods
+def cygwin?
+  @cygwin_flag ||= `ruby -v` =~ /cygwin/
+end
+
+def os
+  @os_flag ||= cygwin? ? `cmd /c ver` : `ver`
+end
+
+def os_2000?
+  os =~ /Version 5.0/
+end
+
+def os_xp?
+  os =~ /XP/
+end
+
+def os_vista?
+  os =~ /Version 6.0/
+end
+
+def os_7?
+  os =~ /Version 6.1/
+end
+
 # Customize RSpec with my own extensions
 module ClassMacros
 
@@ -25,7 +49,7 @@ module ClassMacros
         file, line = args
     end
     File.open(file) do |f|
-      f.lines.to_a[line.to_i-1].gsub( /(spec.*?{)|(use.*?{)|}/, '' ).strip
+      f.lines.to_a[line.to_i-1].gsub(/(spec.*?{)|(use.*?{)|}/, '').strip
     end
   end
 end
@@ -33,86 +57,51 @@ end
 # Customize RSpec with my own extensions
 module InstanceMacros
   def use
-    lambda{yield}.should_not raise_error
+    lambda { yield }.should_not raise_error
   end
 
   def any_block
-    lambda{|*args| args}
+    lambda { |*args| args }
   end
 end
 
-Spec::Runner.configure do |config|
+RSpec.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 os_2000?
-  os =~ /Version 5.0/
-end
-
-def os_xp?
-  os =~ /XP/
+KEY_DELAY        = 0.001
+IMPOSSIBLE       = 'Impossible'
+CONVERSION_ERROR = /Can.t convert/
+SLEEP_DELAY      = 0.02
+APP_PATH         = File.join(File.dirname(__FILE__), "../misc/locknote/LockNote.exe")
+APP_START        = cygwin? ? "cmd /c start `cygpath -w #{APP_PATH}`" : 'start "" "' + APP_PATH + '"'
+WIN_TITLE        = 'LockNote - Steganos LockNote'
+WIN_RECT         = [710, 400, 1210, 800]
+WIN_CLASS        = 'ATL:00434098'
+STATUSBAR_CLASS  = 'msctls_statusbar32'
+TEXTAREA_CLASS   = 'ATL:00434310'
+DESKTOP_CLASS    = '#32769'
+MENU_CLASS       = '#32768'
+
+def any_handle
+  find_window(nil, nil)
 end
 
-def os_vista?
-  os =~ /Version 6.0/
+def not_a_handle
+  123
 end
 
-def os_7?
-  os =~ /Version 6.1/
+def buffer
+  FFI::MemoryPointer.new(:char, 1024)
 end
 
-module WinTest
-
-  KEY_DELAY = 0.001
-  IMPOSSIBLE = 'Impossible'
-  CONVERSION_ERROR = /Can.t convert/
-  SLEEP_DELAY = 0.02
-  APP_PATH = File.join(File.dirname(__FILE__), "../misc/locknote/LockNote.exe" )
-  APP_START = cygwin? ? "cmd /c start `cygpath -w #{APP_PATH}`" : 'start "" "' + APP_PATH + '"'
-  WIN_TITLE = 'LockNote - Steganos LockNote'
-  WIN_RECT = [710, 400, 1210, 800]
-  WIN_CLASS = 'ATL:00434098'
-  STATUSBAR_CLASS = 'msctls_statusbar32'
-  TEXTAREA_CLASS = 'ATL:00434310'
-  DESKTOP_CLASS = '#32769'
-  MENU_CLASS = '#32768'
-
-  def any_handle
-    find_window(nil, nil)
-  end
-
-  def not_a_handle
-    123
-  end
-
-  def buffer
-    FFI::MemoryPointer.new(:char, 1024)
-  end
-
-  def pointer(type=:long, num=1)
-    FFI::MemoryPointer.new(type, num)
-  end
+def pointer(type=:long, num=1)
+  FFI::MemoryPointer.new(type, num)
 end
 
 module WinTestApp
 
-  include WinTest
   include Win::Gui
   #include Win::Gui::Convenience
 
@@ -120,15 +109,15 @@ module WinTestApp
     system APP_START
     sleep SLEEP_DELAY until (handle = find_window(nil, WIN_TITLE))
 
-    textarea = find_window_ex(handle, 0, TEXTAREA_CLASS, nil)
-    app = "Locknote" # App identifier
+    textarea    = find_window_ex(handle, 0, TEXTAREA_CLASS, nil)
+    app         = "Locknote" # App identifier
 
     eigen_class = class << app;
       self;
-    end      # Extracting app's eigenclass
-    eigen_class.class_eval do                  # Defining singleton methods on app
-      define_method(:handle) {handle}
-      define_method(:textarea) {textarea}
+    end # Extracting app's eigenclass
+    eigen_class.class_eval do # Defining singleton methods on app
+      define_method(:handle) { handle }
+      define_method(:textarea) { textarea }
     end
 
     @launched_test_app = app

data/spec/win/dde_spec.rb

@@ -1,529 +1,527 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 require 'win/dde'
 
-module WinDdeTest
-  include WinTest
-  include Win::Dde
-  include Win::Gui::Message
+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
 
-  POKE_STRING = "Poke_string"
+describe Win::Dde, ' contains a set of pre-defined Windows API functions' do
 
-  def dde_cmd
-    APPCLASS_STANDARD
-  end
+  describe '#register_clipboard_format' do
+    spec { use { RegisterClipboardFormat(format_name = "XlTable") } }
+    spec { use { register_clipboard_format(format_name = "XlTable") } }
 
-  def dde_callback
-    ->(*args){}
-  end
+    it 'returns format id (int) if successfully registered format' do
+      id = register_clipboard_format("XlTable")
+      id.should_not == 0
+      id.should_not == nil
+    end
 
-  def zero_id
-    FFI::MemoryPointer.new(:long).write_long(0)
-  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
 
-  def buffer
-    FFI::MemoryPointer.new(:char, 1024)
+    it 'returns nil if not able to register format' do
+      register_clipboard_format("").should == nil
+    end
   end
 
-  def string_pointer
-    FFI::MemoryPointer.from_string("Pointer_string")
-  end
+  describe '#dde_initialize' do
+    after(:each) { dde_uninitialize(@id) if @id }
 
-  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
+    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) } }
 
-  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
+    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
 
-  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
+    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
-    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
+
+    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
-    @data = nil
-  end
 
-  describe Win::Dde, ' contains a set of pre-defined Windows API functions' do
+    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'
 
-    describe '#register_clipboard_format' do
-      spec{ use{ RegisterClipboardFormat(format_name = "XlTable") }}
-      spec{ use{ register_clipboard_format(format_name = "XlTable") }}
+  context 'after initialization:' do
+    before(:each) { @id, status = dde_initialize(APPCLASS_STANDARD) { |*args|} }
+    after(:each) { dde_uninitialize(@id) if @id }
 
-      it 'returns format id (int) if successfully registered format' do
-        id = register_clipboard_format("XlTable")
-        id.should_not == 0
-        id.should_not == nil
-      end
+    describe '#dde_uninitialize' do
 
-      it 'returns same format id for already registered format' do
-        id1 = register_clipboard_format("XlTable")
-        id2 = register_clipboard_format("XlTable")
-        id1.should == id2
+      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 nil if not able to register format' do
-        register_clipboard_format("").should == nil
+      it 'returns false if initialization unsuccessful' do
+        res = dde_uninitialize(12345)
+        res.should == false
       end
-    end
+    end # describe '#dde_uninitialize'
 
-    describe '#dde_initialize' do
-      after(:each) {dde_uninitialize(@id) if @id}
+    describe '#dde_create_string_handle' do
+      after(:each) { dde_free_string_handle(@id, @string_handle) if @string_handle }
 
-      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) }}
+      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 '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
+      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 '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
+      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 '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
+      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 'returns error status if initialization unsuccessful' do
-        @id, status = dde_initialize(12345, APPCLASS_STANDARD) {|*args| }
-        status.should == DMLERR_INVALIDPARAMETER
-        @id.should == nil
+      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 '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
+      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_initialize'
+    end # describe '#dde_create_string_handle'
 
-    context 'after initialization:' do
-      before(:each) {@id, status = dde_initialize(APPCLASS_STANDARD) {|*args| }}
-      after(:each) {dde_uninitialize(@id) if @id}
+    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_uninitialize' do
+      describe '#dde_query_string' do
 
-        spec{ use{ status = DdeUninitialize( @id ) }}
-        spec{ use{ id, status = dde_uninitialize( @id) }}
+        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 'returns true if uninitialization successful' do
-          res = dde_uninitialize(@id)
-          res.should == true
+        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 'returns false if initialization unsuccessful' do
-          res = dde_uninitialize(12345)
-          res.should == false
+        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
-      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
+        it 'retrieves string even if code_page is omitted' do
+          string = dde_query_string(@id, @string_handle)
+          string.should == 'My String 2'
         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
+        it 'returns nil attempting to retrieve invalid handle' do
+          string = dde_query_string(@id, 12345)
+          string.should == nil
         end
+      end # describe '#dde_query_string'
 
-        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
+      describe '#dde_free_string_handle' do
 
-        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
+        spec { use { success = DdeFreeStringHandle(@id, @string_handle) } }
+        spec { use { success = dde_free_string_handle(@id, @string_handle) } }
 
-        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
+        it 'returns true when freeing string handle registered with DDEML' do
+          res = dde_free_string_handle(@id, @string_handle)
+          res.should == true
         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
+
+        it 'returns false attempting to free unregistered handle' do
+          res = dde_free_string_handle(@id, 12345)
+          res.should == false
         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
+
+        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 '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
+        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_connect'
+      end # describe '#dde_free_string_handle'
 
-      describe '#dde_disconnect' do
-        spec{ use{ success = DdeDisconnect(conversation_handle=0) }}
-        spec{ use{ success = dde_disconnect(conversation_handle=0) }}
+      describe '#dde_get_last_error' do
+        spec { use { error_code = DdeGetLastError(@id) } }
+        spec { use { error_code = dde_get_last_error(@id) } }
 
-        it 'fails to disconnect if not valid conversation handle given' do
-          dde_disconnect(12345).should == false
+        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 '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
+        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 '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)]
+        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_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}
+      end # describe '#dde_get_last_error'
 
-      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) }}
+    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 }
 
-      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
+    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 "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
+      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 "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
+      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_client_transaction
+    end # describe '#dde_connect'
 
-    describe '#dde_get_data' do
-      after(:each) { teardown_server}
+    describe '#dde_disconnect' do
+      spec { use { success = DdeDisconnect(conversation_handle=0) } }
+      spec { use { success = dde_disconnect(conversation_handle=0) } }
 
-      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 'fails to disconnect if not valid conversation handle given' do
+        dde_disconnect(12345).should == false
+      end
 
-      it 'original API returns 0 if trying to address invalid dde data handle' do
-        DdeGetData( data_handle = 123, nil, 0, 0).should == 0
+      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 '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
+      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 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
+    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
-        @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)
+        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
+    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 # 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
-        @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)
+        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
+    it 'dde data handle expires once transaction is finished (DDE_FACK)' do
+      setup_server do |*args|
+        @server_calls << extract_values(*args);
+        DDE_FACK
       end
-    end # describe dde_access_data
+      @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) }}
+  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 "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
+    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
+          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
+          dde_unaccess_data(data_handle).should == true
         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)
+        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
+    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)
 
-    end # describe dde_unaccess_data
-  end
-end
+      # 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