vigilem-win32_api 0.0.10

data/spec/vigilem/api_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api'
+
+require 'timeout'
+
+describe Vigilem::Win32API do
+  
+  after(:example) do
+    flush
+  end
+  
+  context '::GetStdHandle' do
+    it 'will return STD_INPUT_HANDLE' do
+      expect(subject.GetStdHandle(described_class::STD_INPUT_HANDLE)).to eql(std_handle)
+    end
+  end
+  
+  
+  context 'methods except GetStdHandle,' do
+    
+    describe '::PeekConsoleInputW' do
+      
+      let(:args) do 
+        {
+          :hConsoleInput => described_class.GetStdHandle(described_class::STD_INPUT_HANDLE),
+          :lpBuffer => described_class::PINPUT_RECORD.new(len = 1),
+          :nLength => len,
+          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+        }
+      end
+      
+      it %q(won't block when the queue is empty) do
+        flush
+        expect do 
+          Timeout::timeout(5) do 
+            subject.PeekConsoleInputW(*args.values)
+          end
+        end.to_not raise_error
+      end
+      
+      it 'will return one when it executes correctly' do 
+        expect(subject.PeekConsoleInputW(*args.values)).to eql 1
+      end
+    end
+    
+    context 'user input' do
+      
+      before :each do
+        flush
+        write_console_input_test
+      end
+      
+      describe '::PeekConsoleInputW' do
+        
+        before :all do 
+          @args = {
+            :hConsoleInput => std_handle,
+            :lpBuffer => described_class::PINPUT_RECORD.new(len = 1),
+            :nLength => len,
+            :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+          }
+        end
+        
+        it 'updates lpNumberOfEventsRead passed in arguments' do  
+          expect do 
+            Timeout::timeout(5) do 
+              subject.PeekConsoleInputW(*@args.values) until @args[:lpNumberOfEventsRead].read_short > 0
+            end
+          end.to_not raise_error
+        end
+        
+        it 'updates the [:lpBuffer].INPUT_RECORD.EventType passed in arguments' do
+          #puts ">#{@args[:lpBuffer].first}"
+          #  expected [] to respond to `a??`
+          #expect(args[:lpBuffer]).to be_a?(described_class::PINPUT_RECORD)
+          
+          expect(0.upto(4).map {|n| 2**n }).to include(@args[:lpBuffer].first.EventType)
+        end
+        
+        it 'updates the [:lpBuffer].INPUT_RECORD.Event.KeyEvent passed in arguments' do
+          expect(@args[:lpBuffer].first.Event.KeyEvent.uChar).to_not eql(0)
+        end
+        
+      end
+      
+      describe '::ReadConsoleInputW' do
+        
+        before :all do
+          @rargs = {
+            :hConsoleInput => std_handle,
+            :lpBuffer => described_class::PINPUT_RECORD.new(len = 2),
+            :nLength => len,
+            :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+          }
+          write_console_input_test
+          described_class.ReadConsoleInputW(*@rargs.values)
+        end
+        
+        it 'pulls input_records from queue' do 
+          expect(@rargs[:lpNumberOfEventsRead].read_short).to be > 1
+        end
+        
+        it 'updates the [:lpBuffer].INPUT_RECORD.EventType passed in arguments' do 
+          expect(@rargs[:lpBuffer].first.EventType).to eql(1)
+        end
+        
+        it 'updates the [:lpBuffer].INPUT_RECORD.Event.KeyEvent passed in arguments' do 
+          expect(@rargs[:lpBuffer].first.Event.KeyEvent.uChar).to_not be_nil
+        end
+        
+      end
+      
+      describe '::PeekConsoleInputW' do
+        
+        before :all do 
+          @pargs = {
+            :hConsoleInput => std_handle,
+            :lpBuffer => described_class::PINPUT_RECORD.new(len = 1),
+            :nLength => len,
+            :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+          }
+          @prargs = {
+            :hConsoleInput => std_handle,
+            :lpBuffer => described_class::PINPUT_RECORD.new(len = 1),
+            :nLength => len,
+            :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+          }
+        end
+        
+        it 'does not effect the queue' do
+          expect(subject.PeekConsoleInputW(*@pargs.values)).to be == subject.ReadConsoleInputW(*@prargs.values)
+        end
+        
+      end
+      
+    end
+  end
+end

data/spec/vigilem/win32_api/console_input_events_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api/constants'
+
+require 'vigilem/win32_api/types'
+
+require 'vigilem/win32_api/console_input_events'
+
+
+describe Vigilem::Win32API::ConsoleInputEvents do
+  
+  describe described_class::MOUSE_EVENT_RECORD do
+    it_behaves_like 'attributes_and_size_test' do
+      let(:ary) { [:dwMousePosition, :dwButtonState, :dwControlKeyState, :dwEventFlags] }
+      let(:sze) { 16 }
+    end
+  end
+  
+  describe described_class::WINDOW_BUFFER_SIZE_RECORD do
+    it_behaves_like 'attributes_and_size_test' do
+      let(:ary) { [:dwSize] }
+      let(:sze) { 4 }
+    end
+  end
+  
+  describe described_class::MENU_EVENT_RECORD do
+    it_behaves_like 'attributes_and_size_test' do
+      let(:ary) { [:dwCommandId] }
+      let(:sze) { 4 }
+    end
+  end
+  
+  describe described_class::FOCUS_EVENT_RECORD do
+    it_behaves_like 'attributes_and_size_test' do
+      let(:ary) { [:bSetFocus] }
+      let(:sze) { 4 }
+    end
+  end
+  
+  describe described_class::KEY_EVENT_RECORD do
+    it_behaves_like 'attributes_and_size_test' do
+      let(:ary) { [:bKeyDown, :wRepeatCount, :wVirtualKeyCode, :wVirtualScanCode, :uChar, :dwControlKeyState] }
+      let(:sze) { 16 }
+    end
+  end
+  
+  describe '::vk_names' do
+    it 'has the list of events' do
+      expect(described_class.vk_names).to eql([:KEY_EVENT, :MOUSE_EVENT, :WINDOW_BUFFER_SIZE_EVENT, :MENU_EVENT, :FOCUS_EVENT])
+    end
+  end
+  
+  describe '::vk_hash' do
+    it 'to be a hash with keys equal to Constant values and values equal to constant names' do
+      expect(described_class.vk_hash).to eql(described_class.vk_names.map.with_object({}) {|vk, hsh| hsh[Vigilem::Win32API::Constants::Events.const_get(vk)] = vk })
+    end
+  end
+=begin
+  describe '::structs' do
+    it 'will return an array of the structs that are the event types' do
+      expect(described_class.structs.sort).to eq([described_class::KEY_EVENT_RECORD,
+                                    described_class::MOUSE_EVENT_RECORD, described_class::WINDOW_BUFFER_SIZE_RECORD,  
+                                    described_class::MENU_EVENT_RECORD, described_class::FOCUS_EVENT_RECORD].sort)
+    end
+  end
+=end
+end

data/spec/vigilem/win32_api/dom/adapter_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api/dom'
+
+describe Vigilem::Win32API::DOM::Adapter do
+  
+  let(:api) { Vigilem::Win32API }
+  
+  after(:example) do
+    flush
+  end
+  
+  let(:dw_numlock) { 0x0020 }
+  
+  let(:input_record) { 
+     api::INPUT_RECORD[api::KEY_EVENT, {:KeyEvent => [1, 1, 0x41, 30, {:UnicodeChar => 65 }, dw_numlock]}]
+  }
+  
+  def key_event_template(type, opts={})
+    {
+      :bubbles=>false, :cancelable=>false, :code=>"KeyA", :detail=>0, :isTrusted=>true, :isComposing=>false,
+      :key=>"A", :location=>0,
+      :modifier_state=>{"Accel"=>false, "Alt"=>false, "AltGraph"=>false, "CapsLock"=>false, 
+                        "Control"=>false, "Fn"=>false, "FnLock"=>false, "Hyper"=>false, "Meta"=>false, 
+                        "NumLock"=>false, "OS"=>false, "ScrollLock"=>false, "Shift"=>false, "Super"=>false, 
+                        "Symbol"=>false, "SymbolLock"=>false},
+      :os_specific=>{:bKeyDown=>1, :wRepeatCount=>1, :wVirtualKeyCode=>65, :wVirtualScanCode=>30, 
+                                    :uChar=>{:UnicodeChar=>65, :AsciiChar=>65}, :dwControlKeyState=>32},
+      :repeat=>false, :timeStamp=>kind_of(Numeric), :type=>type,
+      :view=>nil
+    }.merge(opts)
+  end
+  
+  describe '#handle' do
+    it 'sends Win32API::KEY_EVENT_RECORD events to #to_dom_key_event' do
+      allow(subject).to receive(:to_dom_key_event)
+      expect(subject).to receive(:to_dom_key_event)
+      subject.handle(input_record.event_record)
+    end
+  end
+  
+  describe '#read_many' do
+    it 'blocks until the number passed in is reached' do
+      allow(subject.send(:link)).to receive(:ReadConsoleInput) { [input_record] }
+      expect do
+        Timeout::timeout(4) {
+          subject.read_many(3)
+        }
+      end.to raise_error(Timeout::Error)
+    end
+    
+    it 'retrieves multiple dom message' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record, input_record])
+      Timeout::timeout(4) {
+        expect(subject.read_many(2)).to contain_exactly(
+            an_object_having_attributes(key_event_template("keydown")),
+            an_object_having_attributes(key_event_template("keypress"))
+          )
+      }
+    end
+    
+    it 'will fill the buffer with the leftovers' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record, input_record])
+      subject.read_many(2)
+      Timeout::timeout(4) {
+        expect(subject.buffer.to_a).to contain_exactly(
+            an_object_having_attributes(key_event_template("keydown", repeat: true)),
+            an_object_having_attributes(key_event_template("keypress", repeat: true))
+          )
+       }
+    end
+  end
+  
+  describe '#read_many_nonblock' do
+    
+    it %q{doesn't block and returns nil when nothing in the queue} do
+      allow(subject.send(:link)).to receive(:read_console_input).with(:nLength => 1, :blocking => true).and_call_original
+      allow(subject.send(:link)).to receive(:ReadConsoleInput) { sleep 3.5 }
+      expect do
+        Timeout::timeout(3) {
+          subject.read_many_nonblock(3)
+        }
+      end.not_to raise_error
+    end
+    
+    it 'retrieves multiple dom messages' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record, input_record])
+      expect(subject.read_many_nonblock(2)).to contain_exactly(
+          an_object_having_attributes(key_event_template("keydown")),
+          an_object_having_attributes(key_event_template("keypress"))
+        )
+    end
+    
+    it 'will fill the buffer with the leftovers' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record, input_record])
+      subject.read_many_nonblock(2)
+      expect(subject.buffer.to_a).to contain_exactly(
+          an_object_having_attributes(key_event_template("keydown", repeat: true)),
+          an_object_having_attributes(key_event_template("keypress", repeat: true))
+        )
+    end
+    
+    class UnknownEvent
+      def event_record
+      end
+    end
+    
+    it 'will return emty array if none of the events are handled' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([UnknownEvent.new])
+      expect(subject.read_many_nonblock(2)).to eql([])
+    end
+    
+  end
+  
+  describe '#read_one' do
+    
+    it 'retrieves one dom message' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record])
+      Timeout::timeout(4) {
+        expect(subject.read_one).to be_a(Vigilem::DOM::KeyboardEvent) and
+            have_attributes(key_event_template("keydown"))
+      }
+    end
+    
+    it 'will block when no messages in buffer and non in the windows message queue' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_call_original
+      allow(subject.send(:link)).to receive(:ReadConsoleInput) { sleep 2.5 }
+      expect do
+        Timeout::timeout(2) {
+          subject.read_one
+        }
+      end.to raise_error(Timeout::Error)
+    end
+  end
+  
+  describe '#read_one_nonblock' do
+    
+    it 'retrieves one dom message' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record])
+      Timeout::timeout(4) {
+        expect(subject.read_one_nonblock).to be_a(Vigilem::DOM::KeyboardEvent) and
+            have_attributes(key_event_template("keydown"))
+      }
+    end
+    
+    it 'will fill the buffer with the leftovers' do
+      allow(subject.send(:link)).to receive(:read_many_nonblock).and_return([input_record])
+      subject.read_one_nonblock
+      expect(subject.buffer.to_a).to contain_exactly(
+          an_object_having_attributes(key_event_template("keypress"))
+        )
+    end
+    
+    it %q{will not block when no messages in buffer} do
+      allow(subject.send(:link)).to receive(:read_console_input).with(:nLength => 1, :blocking => false).and_call_original
+      allow(subject.send(:link)).to receive(:ReadConsoleInput) { sleep 2.5 }
+      expect do
+        Timeout::timeout(2) {
+          subject.read_one_nonblock
+        }
+      end.not_to raise_error
+    end
+  end
+end

data/spec/vigilem/win32_api/dom/code_values_tables_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+require 'vigilem/dom'
+
+require 'vigilem/win32_api/dom/code_values_tables'

data/spec/vigilem/win32_api/dom/input_record_utils_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+
+require 'vigilem/dom'
+
+require 'vigilem/win32_api'
+
+require 'vigilem/win32_api/input_system_handler'
+
+require 'vigilem/win32_api/dom/input_record_utils'
+
+
+describe Vigilem::Win32API::DOM::InputRecordUtils do
+  
+  let(:api) { Vigilem::Win32API }
+  
+  let(:dw_numlock) { 0x0020 }
+  
+  let(:dw_lmenu) { 0x0002 }
+  
+  let(:dw_rmenu) { 0x0001 }
+  
+  let(:dw_shift) { 0x0010 }
+  
+  let(:key_event_record) { api::KEY_EVENT_RECORD[1, 1, 0x41, 30, {:UnicodeChar => 65 }, dw_numlock] }
+  
+  let(:event_record_lmenu)  { api::KEY_EVENT_RECORD[1, 1, 0x12, 30, {:UnicodeChar => 0 }, dw_numlock + dw_lmenu] }
+  
+  let!(:host) do
+    class IRU
+      include Vigilem::Core::Adapters::Adapter
+      include Vigilem::Win32API::Rubyized
+      include Vigilem::Win32API::DOM::InputRecordUtils
+      
+      def initialize
+        self.win32_api_rubyized_src = self.link
+      end
+      
+      def link
+        @isys ||= Vigilem::Win32API::InputSystemHandler.new
+      end
+    end
+    IRU.new
+  end
+  
+  describe '#current_keys' do
+    it 'defaults to an empty array' do
+      expect(host.current_keys).to eql([])
+    end
+  end
+  
+  describe '#to_dom_key_event' do
+    
+    def key_event(type, opts={})
+      {
+        bubbles: false, cancelable: false, code: "KeyA", detail: 0, isTrusted: true, 
+        isComposing: false, key: "A", location: 0, 
+        modifier_state: {"Accel"=>false, "Alt"=>false, "AltGraph"=>false, "CapsLock"=>false, "Control"=>false, 
+                         "Fn"=>false, "FnLock"=>false, "Hyper"=>false, "Meta"=>false, "NumLock"=>false, "OS"=>false, 
+                         "ScrollLock"=>false, "Shift"=>false, "Super"=>false, "Symbol"=>false, "SymbolLock"=>false}, 
+        os_specific: {:bKeyDown=>1, :wRepeatCount=>1, :wVirtualKeyCode=>65, :wVirtualScanCode=>30, 
+                                                  :uChar=>{:UnicodeChar=>65, :AsciiChar=>65}, :dwControlKeyState=>dw_numlock}, 
+        repeat: false, timeStamp: kind_of(Numeric), type: type, view: nil
+      }.merge(opts)
+    end
+    
+    context 'simple conversion' do
+      
+      let!(:result) { host.to_dom_key_event(key_event_record) }
+      
+      it 'converts an input_record to a DOM Event' do
+        expect(result).to match [
+            an_object_having_attributes(key_event('keydown')),
+            an_object_having_attributes(key_event('keypress'))
+          ]
+      end
+      
+      # @todo be more specific
+      it 'updates #current_keys' do
+        expect(host.current_keys.size).to be > 0
+      end
+    end
+    context 'repeats' do
+      
+      let(:repeat_results) { 1.upto(2).map {|n| host.to_dom_key_event(key_event_record) } }
+      
+      it 'converts an input_record to a DOM Event and keeps track of state' do
+        expect(repeat_results).to match [
+            [an_object_having_attributes(key_event('keydown')),   # its wrongly making this repeat
+             an_object_having_attributes(key_event('keypress'))], # its wrongly making this repeat
+            [an_object_having_attributes(key_event('keydown', repeat: true)), 
+            an_object_having_attributes(key_event('keypress', repeat: true))] # chrome 39.0.2171.95 m produces `false'
+          ]
+      end
+    end
+    
+  end
+  
+  describe '#dw_control_key_state_vks' do
+    it 'lists the names of the constants that represent the dw_control_state' do
+      expect(host.dw_control_key_state_vks(dw_numlock + dw_lmenu)).to eql([:LEFT_ALT_PRESSED, :NUMLOCK_ON])
+    end
+  end
+  
+  describe '#location_less_vks_map' do
+    it 'returns a Hash with vk as keys' do
+      expect(host.location_less_vks_map.keys).to all( be_instance_of(Symbol) )
+    end
+    
+    it 'returns a Hash with Regexp as values' do
+      expect(host.location_less_vks_map.values).to all( be_instance_of(Regexp) )
+    end
+  end
+  
+  describe '#vk_without_location_info?' do
+    it 'returns whether or not a virtual key need location info' do
+      expect(:VK_MENU).to be_truthy
+    end
+  end
+  
+  describe '#shift_scan_code_to_location_vk' do
+    
+    let(:l_shift) { IRU::VK_LSHIFT }
+    
+    let(:l_shift_vsc) { api.MapVirtualKeyW(l_shift, IRU::MapVK::VK_TO_VSC) }
+    
+    it 'creates a hash that maps the scancodes to :VK_LSHIFT and :VK_RSHIFT ' do
+      expect(host.shift_scan_code_to_location_vk[l_shift_vsc]).to eql(:VK_LSHIFT)
+    end
+  end
+  
+  describe '::flip_lr_sides' do
+    it 'converts "l" or "L" to "r" or "R"' do
+      expect(described_class.flip_lr_sides('L')).to eql('R')
+    end
+  end
+  
+  describe '::lr_location_from_name' do
+    it 'pulls the "L" or "R" from the string name' do
+      expect(described_class.lr_location_from_name(:LEFT_CTRL_PRESSED)).to eql('L')
+    end
+  end
+  
+  describe '::empty_or_null?' do
+    it 'returns true for empty Strings ' do 
+      expect(described_class.empty_or_null?("")).to be_truthy
+    end
+    
+    it 'returns true for a String with only "\x00"' do 
+      expect(described_class.empty_or_null?("\x00\x00")).to be_truthy
+    end
+  end
+  
+  describe '#dom_location' do
+    
+    let(:vk_menu_vsc) { api.MapVirtualKeyW(IRU::VK_MENU, IRU::MapVK::VK_TO_VSC) }
+    
+    context ', both ALT\'s are pressed yet niether in the current_keys' do
+      
+      let(:dw_state_names) { host.dw_control_key_state_vks(3) }
+      
+      it 'will raise an error in this situation' do
+        expect { host.dom_location(:VK_MENU, vk_menu_vsc, dw_state_names) }.to raise_error
+      end
+      
+    end
+    
+    context 'generic vk with dw_state_names' do
+    
+      let(:dw_state_names) { host.dw_control_key_state_vks(2) }
+      
+      let(:dw_state_names_right) { host.dw_control_key_state_vks(1) }
+      
+      it 'will get left the location from the dw_state_name' do
+        expect(host.dom_location(:VK_MENU, vk_menu_vsc, dw_state_names)).to eql(1)
+      end
+      
+      it 'will get right the location from the dw_state_name' do
+        expect(host.dom_location(:VK_MENU, vk_menu_vsc, dw_state_names_right)).to eql(2)
+      end
+    end
+    
+  end
+  
+  describe '#lr_not_in_name' do
+    
+    let(:vk_menu_vsc) { api.MapVirtualKeyW(IRU::VK_MENU, IRU::MapVK::VK_TO_VSC) }
+    
+    let(:vk_rmenu_vsc) { api.MapVirtualKeyW(IRU::VK_RMENU, IRU::MapVK::VK_TO_VSC) }
+    
+    let(:vk_rshift_vsc) { api.MapVirtualKeyW(IRU::VK_RSHIFT, IRU::MapVK::VK_TO_VSC) }
+    
+    let(:lr_menu_dw_state_names) { host.dw_control_key_state_vks(dw_numlock + dw_lmenu + dw_rmenu) }
+    
+    let(:l_menu_dw_state_names) { host.dw_control_key_state_vks(dw_numlock + dw_lmenu) }
+    
+    let(:dw_state_names_w_shift) { host.dw_control_key_state_vks(dw_shift) }
+    
+    it 'gets the location info from virtual-key and dw_state_names' do
+      expect(host.lr_not_in_name(:VK_MENU, vk_menu_vsc, l_menu_dw_state_names)).to eql('l')
+    end
+    
+    it 'gets the location info from the scan code' do
+      expect(host.lr_not_in_name(:VK_SHIFT, vk_rshift_vsc, dw_state_names_w_shift)).to eql('r')
+    end
+    
+    context 'with current keys' do
+      let!(:converted_result) { host.to_dom_key_event(event_record_lmenu) }
+      
+      it 'gets the location info from the #current keys' do
+        expect(host.lr_not_in_name(:VK_MENU, vk_rmenu_vsc, lr_menu_dw_state_names)).to eql('r')
+      end
+    end
+  end
+  
+  describe '#dom_key' do
+    
+    let(:l_shift) { IRU::VK_LSHIFT }
+    
+    it 'converts modifier virtual-key to dom_key' do
+      expect(host.dom_key(:VK_SHIFT, 0)).to eql('Shift')
+    end
+    
+    it 'converts character virtual-key to dom_key' do
+      expect(host.dom_key(:VK_A, 97)).to eql('a')
+    end
+  end
+  
+  describe '#dom_code' do
+    it 'produces the code attribute for a character key For DOM::Keyboard Event' do
+      expect(host.dom_code(:VK_A, 65, 0)).to eql('KeyA')
+    end
+    
+    it 'produces the code attribute for a modifier key For DOM::Keyboard Event' do
+      expect(host.dom_code(:VK_MENU, 0, 'l')).to eql('AltLeft')
+    end
+    
+    it 'produces the code attribute for a modifier key For DOM::Keyboard Event' do
+      expect(host.dom_code(:VK_RETURN, 10, 3, :ENHANCED_KEY)).to eql('NumpadEnter')
+    end
+  end
+  
+  describe '#dom_modifiers' do
+    
+    it 'convert dw_control_names to more typical modifier names' do
+      expect(::VDOM::KeyboardEvent).to receive(:shared_keyboard_and_mouse_event_init).with([:alt, :numlock])
+      host.dom_modifiers(:LEFT_ALT_PRESSED, :NUMLOCK_ON)
+    end
+    it 'converts dw_control_state_names to an array of symbols' do
+      expect(host.dom_modifiers(:LEFT_ALT_PRESSED, :NUMLOCK_ON)).to eql({ :altKey=>true, :keyModifierStateAltGraph=>false, :keyModifierStateCapsLock=>false,
+                                            :ctrlKey=>false, :keyModifierStateFn=>false, :keyModifierStateFnLock=>false, :keyModifierStateHyper=>false,  
+                                            :metaKey=>false, :keyModifierStateNumLock=>true, :keyModifierStateOS=>false, :keyModifierStateScrollLock=>false, 
+                                            :shiftKey=>false, :keyModifierStateSuper=>false, :keyModifierStateSymbol=>false, :keyModifierStateSymbolLock=>false })
+    end
+  end
+end

data/spec/vigilem/win32_api/dom/key_values_tables_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+require 'vigilem/dom'
+
+require 'vigilem/win32_api/dom/key_values_tables'