vigilem-win32_api 0.0.10

data/spec/vigilem/win32_api/eventable_spec.rb

@@ -0,0 +1,96 @@
+require 'timeout'
+
+describe Vigilem::Win32API::Eventable do
+  
+  before :all do
+    EventableAdapter = Class.new do
+      include Vigilem::Core::Adapters::Adapter
+      include Vigilem::Win32API::Rubyized
+      include Vigilem::Win32API::Eventable
+      def initialize(lnk=Vigilem::Win32API::InputSystemHandler.new)
+        initialize_adapter(lnk)
+        self.win32_api_rubyized_source = link()
+      end
+    end
+  end
+  
+  let(:adapt) do
+    EventableAdapter.new
+  end
+  
+  describe 'has_any?' do
+    
+    it 'checks peek_console_input and if the lpBuffer has any messages' do
+      allow(adapt).to receive(:peek_console_input) { %w(a b c) }
+      expect(adapt.has_any?).to be_truthy
+    end
+    
+    it 'returns false when peek_console_input lpBuffer is empty' do
+      allow(adapt).to receive(:peek_console_input) { [] }
+      expect(adapt.has_any?).to be_falsey
+    end
+  end
+  
+  describe '#read_many_nonblock' do
+    
+    it 'reads many messages from the input buffer returning if it would block/stopping at limit' do
+      allow(adapt).to receive(:peek_console_input) { %w(a b c) }
+      allow(adapt).to receive(:read_console_input).with(:nLength => 1, :blocking => false) { %w(a) }
+      expect(adapt.read_many_nonblock).to eql(%w(a))
+    end
+  end
+  
+  describe '#read_many' do
+    
+    it 'reads the default amount of messages from the input buffer' do
+      allow(adapt).to receive(:read_console_input).with(:nLength => 1, :blocking => true) { %w(a) }
+      expect(adapt.read_many).to eql(%w(a))
+    end
+    
+    it 'blocks until the number passed in is reached' do
+      allow(adapt).to receive(:read_console_input).with(:nLength => 3, :blocking => true).and_call_original
+      allow(adapt.send(:link)).to receive(:ReadConsoleInput) { %w(a) }
+      expect do
+        Timeout::timeout(4) {
+          adapt.read_many(3)
+        }
+      end.to raise_error(Timeout::Error)
+    end
+    
+    it 'reads many messages from the input_buffer' do
+      allow(adapt).to receive(:read_console_input).with(:nLength => 3, :blocking => true) { %w(a b c) }
+      expect(adapt.read_many(3)).to eql(%w(a b c))
+    end
+  end
+  
+  describe 'read_one_nonblock' do
+    
+    it 'reads one message off the input buffer' do
+      allow(adapt).to receive(:peek_console_input) { %w(a) }
+      allow(adapt).to receive(:read_console_input) { %w(a) }
+      expect(adapt.read_one_nonblock).to eql('a')
+    end
+    
+    it %q(doesn't block) do
+      allow(adapt).to receive(:peek_console_input) { [] }
+      expect(adapt.read_one_nonblock).to eql(nil)
+    end
+  end
+  
+  describe '#read_one' do
+    it 'reads one message off the input buffer' do
+      allow(adapt).to receive(:read_console_input) { %w(a) }
+      expect(adapt.read_one).to eql('a')
+    end
+    
+    it %q(blocks when no messages are in the buffer) do
+      allow(adapt).to receive(:read_console_input).and_call_original
+      allow(adapt.send(:link)).to receive(:ReadConsoleInput) { sleep 4 }
+      expect do
+        Timeout::timeout(3) do
+          adapt.read_one
+        end
+      end.to raise_error(Timeout::Error)
+    end
+  end
+end

data/spec/vigilem/win32_api/input__record_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api/types'
+require 'vigilem/win32_api/console_input_events'
+
+require 'vigilem/win32_api/input__record'
+
+describe Vigilem::Win32API do
+  
+      
+  describe 'constants' do
+    specify { expect(described_class::INPUT_RECORD).to eql(described_class::InputRecord) }
+  end
+  
+  describe described_class::INPUT_RECORD do
+    
+    it 'will create a shell object, when no arguments, without error' do
+      expect { described_class.new }.to_not raise_error
+    end
+    
+    describe '::EventType' do
+      it 'will have an EventType' do
+        expect(described_class.new).to respond_to(:EventType)
+      end
+      
+      it 'return the ID representing the window event type' do
+        expect(described_class[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97 }, 32]}].EventType).to eql(1)
+      end
+    end
+    
+    describe '::Event' do
+      it 'will be a union' do
+        expect(subject.Event).to be_a(FFI::Union)
+      end
+    end
+    
+    let(:ir) { 
+      ipt = Vigilem::Win32API::INPUT_RECORD.new()
+      ipt.type_of(:Event).struct_class.new()
+      ipt
+    }
+    
+    describe described_class::Event do
+      let(:correct) do
+        { :KeyEvent => (api = Vigilem::Win32API)::KEY_EVENT_RECORD,
+        :MouseEvent => api::MOUSE_EVENT_RECORD,
+        :WindowBufferSizeEvent => api::WINDOW_BUFFER_SIZE_RECORD,
+        :MenuEvent => api::MENU_EVENT_RECORD,
+        :FocusEvent => api::FOCUS_EVENT_RECORD
+        }
+      end
+      
+      specify 'that fields in the the union match the correct class' do
+        expect(ir.Event.class.layout.fields.all? {|fld| correct[fld.name].name == fld.type.struct_class.name }).to be_truthy
+      end
+    end
+    
+    describe '#to_h' do
+        
+      let(:hsh) { input_record.to_h }
+      
+      it 'converts the struct attributes into a Hash' do
+        expect(hsh[:EventType]).to eq(1)
+        expect(hsh[:Event]).to eql({:FocusEvent=>{:bSetFocus=>1}, 
+                                  :KeyEvent=>{:bKeyDown=>1, :wRepeatCount=>1, :wVirtualKeyCode=>70, :wVirtualScanCode=>33, 
+                                          :uChar=>{:UnicodeChar=>97, :AsciiChar=>97}, :dwControlKeyState=>32}, 
+                                  :MenuEvent=>{:dwCommandId=>1}, 
+                                  :MouseEvent=>{:dwMousePosition=>{:x=>1, :y=>0}, 
+                                  :dwButtonState=>4587521, :dwControlKeyState=>6357025, :dwEventFlags=>32}, 
+                                  :WindowBufferSizeEvent=>{:dwSize=>{:x=>1, :y=>0}}
+                                })
+      end
+    end
+    
+    describe '#type' do
+      it 'returns the EventType' do
+        expect(input_record.type).to eql(input_record.EventType)
+      end
+    end
+    describe '#event_record' do
+      
+      it %q(returns the Event that's populated) do
+        expect(input_record.event_record.bytes).to eql(input_record.Event.KeyEvent.bytes)
+      end
+    end
+    
+    let(:input_record) do
+      described_class[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97 }, 32]}]
+    end
+    
+    let(:event_record_class) { 'Vigilem::Win32API::ConsoleInputEvents::KEY_EVENT_RECORD' }
+    
+    context 'class_methods' do
+      
+      describe '::event_record' do
+        it %q(returns the Event that's populated) do
+          expect(described_class.event_record(input_record).class.name).to eql(event_record_class)
+        end
+      end
+    end
+  
+    context 'instance methods' do
+      
+    end
+=begin
+    describe '::event_types' do
+      it %q(will return the id's of windows events) do
+        expect(described_class.event_types).to eq([16, 1, 8, 2, 4])
+      end
+    end
+=end
+  end
+end

data/spec/vigilem/win32_api/input_system_handler_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api/input_system_handler'
+
+describe Vigilem::Win32API::InputSystemHandler do
+  
+  describe '#GetStdHandle' do
+    
+    it 'forwards the call to the underlying system' do
+      expect(subject.send(:link)).to receive(:GetStdHandle)
+      subject.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE)
+    end
+  end
+  
+  context 'private' do
+    
+    let(:input_record)  { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
+    let(:input_record2) { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
+    
+    let(:events) { [input_record, input_record2] }
+    
+    let(:lpBuffer) { Vigilem::Win32API::PINPUT_RECORD.new(3) }
+    
+    let(:lpNumberOfEventsRead) { FFI::MemoryPointer.new(:dword, 1) }
+    
+    describe '#_update_out_args' do
+      
+      let!(:input_system) do
+        allow(subject).to receive(:_update_out_args).and_call_original
+        subject
+      end
+      
+      let!(:result) { input_system.send(:_update_out_args, lpBuffer, lpNumberOfEventsRead, events) }
+      
+      it 'updates lpNumberOfEventsRead' do
+        expect(FFIUtils.read_typedef(lpNumberOfEventsRead, :dword)).to eql(events.size)
+      end
+      
+    end
+  end
+  
+  describe '#PeekConsoleInput' do
+    context 'empty buffer' do
+      let(:args) do 
+        {
+          :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
+          :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 1),
+          :nLength => len,
+          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+        }
+      end
+      
+      let!(:input_system) do
+        lnk = spy(subject.send(:link), :semaphore => @monitor ||= Monitor.new)
+        subject.send(:link=, lnk)
+        allow(subject).to receive(:buffer).and_call_original
+        allow(subject).to receive(:PeekConsoleInput).and_call_original
+        subject.PeekConsoleInput(*args.values)
+        subject
+      end
+      
+      it 'checks the buffer first' do
+        expect(input_system).to have_received(:buffer).at_least(1).times
+      end
+      
+      it 'calls the link#PeekConsoleInput' do
+        expect(input_system.send(:link)).to have_received(:PeekConsoleInputW)
+      end
+    end
+    context 'buffer > length' do
+      let(:input_record) { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
+      let!(:input_system) do
+        subject.buffer.concat(3.times.map { input_record.dup })
+        lnk = spy(subject.send(:link), :semaphore => @monitor ||= Monitor.new)
+        subject.send(:link=, lnk)
+        allow(subject).to receive(:buffer).and_call_original
+        allow(subject).to receive(:PeekConsoleInput).and_call_original
+        subject.PeekConsoleInput(*args.values)
+        subject
+      end
+      
+      let(:args) do 
+        {
+          :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
+          :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 1),
+          :nLength => len,
+          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+        }
+      end
+      
+      it 'checks the buffer first then call the system' do
+        expect(subject).to receive(:buffer).and_call_original
+        subject.PeekConsoleInput(*args.values)
+      end
+      
+      it %q{doesn't call link#PeekConsoleInput} do
+        expect(input_system.send(:link)).not_to have_received(:PeekConsoleInputW)
+      end
+      
+    end
+    
+  end
+  
+  describe '#ReadConsoleInput' do
+    context 'empty buffer' do
+      let(:args) do 
+        {
+          :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
+          :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 3),
+          :nLength => len,
+          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+        }
+      end
+      
+      let(:input_record) { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
+      
+      let!(:input_system) do
+        lnk = spy(subject.send(:link), :semaphore => @monitor ||= Monitor.new)
+        subject.send(:link=, lnk)
+        allow(subject).to receive(:buffer).and_call_original
+        allow(subject).to receive(:ReadConsoleInput).and_call_original
+        subject.ReadConsoleInput(*args.values)
+        subject
+      end
+      
+      it 'checks the buffer first' do
+        expect(input_system).to have_received(:buffer).at_least(:once)
+      end
+      
+      it 'calls the link#ReadConsoleInput' do
+        expect(input_system.send(:link)).to have_received(:ReadConsoleInputW).at_least(:once)
+      end
+    end
+    
+    context 'buffer > length' do
+      let(:input_record) { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
+      let!(:input_system) do
+        subject.buffer.concat(3.times.map { input_record.dup })
+        lnk = spy(subject.send(:link), :semaphore => @monitor ||= Monitor.new)
+        subject.send(:link=, lnk)
+        allow(subject).to receive(:buffer).and_call_original
+        allow(subject).to receive(:PeekConsoleInput).and_call_original
+        subject.ReadConsoleInput(*args.values)
+        subject
+      end
+      
+      let(:args) do 
+        {
+          :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
+          :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 1),
+          :nLength => len,
+          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+        }
+      end
+      
+      it 'checks the buffer first then call the system' do
+        expect(subject).to receive(:buffer).at_least(:once).and_call_original
+        subject.ReadConsoleInput(*args.values)
+      end
+    end
+    
+  end
+  
+end

data/spec/vigilem/win32_api/p_input__record_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api/p_input__record'
+
+describe Vigilem::Win32API::PINPUT_RECORD do
+  
+  let(:api) { Vigilem::Win32API }
+  
+  before :each do
+    @pir = described_class.new(3, 
+              api::INPUT_RECORD[:EventType => 0x0001, :Event => api::INPUT_RECORD::Event.new], 
+              api::INPUT_RECORD[:EventType => 0x0008, :Event => api::INPUT_RECORD::Event.new])
+  end
+  
+  subject { @pir }
+  
+  context 'when first created' do
+    
+    specify { expect(subject.first).to be_a api::INPUT_RECORD }
+    
+    specify { expect(subject.first.values.first).to eql(0x0001) }
+    
+    specify { expect(subject[1].values.first).to eql(0x0008) }
+    
+    it 'will update the underlying ptr' do
+      expect(api::INPUT_RECORD.new(subject.ptr).values.first).to eql(1)
+    
+      #::Win32API::INPUT_RECORD.new(@pir.ptr.read_pointer).values #causes segfault because it 
+      # wasnt saved as a pointer, it was saved as bytes, maybe subclass pointer? to get around this
+    end
+  end
+  
+  describe 'update-able' do
+    
+    it 'will increase size' do 
+      expect((subject << api::INPUT_RECORD.new).length).to eql(3)
+    end
+    
+    it %q(won't allow a length more than the init max value) do
+      expect { subject.concat [api::INPUT_RECORD.new, api::INPUT_RECORD.new ] }.to raise_error
+    end
+  end
+end

data/spec/vigilem/win32_api/rubyized_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+require 'vigilem/win32_api'
+
+# @todo brittle and hags, need to use a double for the brittle calls, and 
+# seperate out teh os specific stuff
+describe Vigilem::Win32API::Rubyized do
+  
+  after(:example) do
+    flush
+  end
+  
+  let(:handler_class) { ::Vigilem::Win32API::InputSystemHandler }
+  let(:handler) { handler_class.new }
+  
+  let(:adapt) do
+    class WinRubyAPIAdapter
+      include Vigilem::Core::Adapters::Adapter
+      include Vigilem::Win32API::Rubyized
+      def initialize(lnk=Vigilem::Win32API::InputSystemHandler.new)
+        initialize_adapter(lnk)
+        self.win32_api_rubyized_source = lnk
+      end
+    end
+    WinRubyAPIAdapter.new.attach(handler)
+  end
+  
+  describe '#get_std_handle' do
+    it 'calls link.GetStdHandle' do
+      expect(adapt.send(:win32_api_rubyized_source)).to receive(:GetStdHandle).with(Vigilem::Win32API::STD_INPUT_HANDLE)
+      adapt.get_std_handle()
+    end
+  end
+  
+  context 'methods except #get_std_handle,' do
+    let(:pointer_args) do
+      { 
+        :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(1),
+        :lpNumberOfEventsRead => FFI::MemoryPointer.new(:DWORD, 1) 
+      }
+    end
+    
+    let(:non_pointer_args) do
+      { 
+        :hConsoleInput => adapt.get_std_handle,
+        :nLength => 1, 
+      }
+    end
+    
+    let(:all_non_pointer_args) do
+      non_pointer_args.merge( :blocking => nil )
+    end
+    
+    let(:all_args) do
+      non_pointer_args.merge(pointer_args)
+    end
+    
+    context 'private' do
+      describe '#_options' do
+        it 'returns default arguments' do
+          arg = adapt.send(:_options)
+          
+          # @todo
+          expect(arg).to match a_hash_including(
+              #{ :lpBuffer => instance_of(Vigilem::Win32API::PINPUT_RECORD),
+              #  :lpNumberOfEventsRead => kind_of(FFI::MemoryPointer)
+              #}.merge(non_pointer_args)
+              non_pointer_args
+            )
+          
+          #expect(arg).to include(:lpBuffer => instance_of(Vigilem::Win32API::PINPUT_RECORD))
+          #expect(arg).to include(non_pointer_args)
+            # a_kind_of/instance_of(FFI::MemoryPointer) throws `Invalid Memory'
+          #expect(arg[:lpNumberOfEventsRead]).to be_a(FFI::MemoryPointer)
+        end
+        
+        it 'configures the default lpBuffer based on nLength' do
+          args = adapt.send(:_options, :nLength => 3)
+          expect([args[:lpBuffer].max_size, args[:nLength]]).to eql([3, 3])
+        end
+        
+        it 'configures the default nLength based on lpBuffer.size' do
+          args = adapt.send(:_options, :lpBuffer => [nil] * 4)
+          expect([args[:lpBuffer].size, args[:nLength]]).to eql([4, 4])
+        end
+      end
+    end
+    
+    describe '#peek_console_input' do
+      it %q(won't block when the queue is empty) do
+        flush
+        expect do 
+          Timeout::timeout(5) do 
+            adapt.peek_console_input()
+          end
+        end.to_not raise_error
+      end
+    
+      it 'calls link.PeekConsoleInput' do
+        expect(adapt.send(:win32_api_rubyized_source)).to receive(:PeekConsoleInput)
+        adapt.peek_console_input()
+      end
+    end
+    
+    describe '#read_console_input' do
+      # need to allocConsole so it's isolated
+=begin
+      it %q(will block when the queue is empty) do
+        flush
+        expect do 
+          Timeout::timeout(5) do 
+            adapt.read_console_input()
+          end
+        end.to raise_error(Timeout::Error)
+      end
+=end
+      it %q(won't block when the buffer has somthing in it) do
+        write_console_input_test
+        expect do 
+          Timeout::timeout(5) do 
+            adapt.read_console_input()
+          end
+        end.to_not raise_error
+      end
+      
+      it 'calls link.ReadConsoleInput' do
+        expect(adapt.send(:win32_api_rubyized_source)).to receive(:ReadConsoleInput)
+        adapt.read_console_input()
+      end
+    end
+    
+  end
+  
+end

data/spec/vigilem/win32_api/types_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Vigilem::Win32API::Types do
+=begin
+    # Check for 64b operating systems.
+    if Vigilem::Core::System.x64bit?
+      ::FFI.typedef(:uint64, :ulong_ptr)
+      ::FFI.typedef(:int64, :long_ptr)
+    else
+      ::FFI.typedef(:ulong, :ulong_ptr)
+      ::FFI.typedef(:long, :long_ptr)
+    end
+=end
+  describe described_class::PVOID do
+    
+    describe '::from_native' do
+      
+      #def from_native(value, ctx)
+      #  value.address
+      #end
+    end
+    
+    describe '::to_native' do
+      
+=begin
+      def to_native(value, ctx)
+        case
+        when value.kind_of?(FFI::Pointer)
+          value
+        when value.kind_of?(FFI::Struct)
+          value.to_ptr
+        else
+          FFI::Pointer.new(value.to_i)
+        end
+      end
+=end
+    end
+  end
+=begin
+    
+    # 
+    class PBYTE
+    
+      include ::Vigilem::FFI::ArrayPointerSync
+      
+      # @see    ArrayPointerSync#initialize_array_sync
+      # @param  [Integer || ::FFI::Pointer] max_len_or_ptr
+      # @param  [Array] 
+      def initialize(max_len_or_ptr, *init_values)
+        initialize_array_sync(max_len_or_ptr, *init_values)
+      end
+      
+      class << self
+        
+        # 
+        # [Class || Symbol] 
+        def array_type
+          :BYTE
+        end
+        
+        # Converts the specified value from the native type.
+        # @return [Integer]
+        def from_native(value, ctx)
+          value
+        end
+        
+        # Converts the specified value to the native type.
+        # @return [::FFI::Pointer]
+        def to_native(value, ctx)
+          case 
+          when value.is_a?(::FFI::Pointer)
+            value
+          when value.is_a?(self)
+            value.ptr
+          else
+            raise "#{value} is an Unsupported Type"
+          end
+        end
+      end
+    end
+    
+    ::FFI.typedef(PVOID, :p_void)
+    ::FFI.typedef(PVOID, :PVOID)
+    
+    ::FFI.typedef(PBYTE, :PBYTE)
+    
+    ::FFI.typedef(:p_void, :handle)
+    ::FFI.typedef(:PVOID, :HANDLE)
+    
+    ::FFI.typedef(:handle, :h_wnd)
+    ::FFI.typedef(:handle, :HWND)
+    
+    ::FFI.typedef(:ushort, :word)
+    ::FFI.typedef(:ushort, :WORD)
+    
+    ::FFI.typedef(:ushort, :wchar)
+    ::FFI.typedef(:ushort, :WCHAR)
+    
+    ::FFI.typedef(:uint, :dword)
+    ::FFI.typedef(:uint, :DWORD)
+    
+    ::FFI.typedef(:int, :BOOL)
+    
+    ::FFI.typedef(:uchar, :BYTE)
+    
+    ::FFI.typedef(:ulong_ptr, :WPARAM)
+    ::FFI.typedef(:long_ptr, :LPARAM)
+=end
+  describe described_class::POINT do
+    
+    it 'will have methods as attrs' do
+      expect(described_class.new).to respond_to(:x, :y)
+    end
+    
+    it %q(will have an size eql to it's layout types sizes) do
+      expect(described_class.new.to_ptr.type_size).to eql(described_class.size)
+    end
+  end
+  
+  describe described_class::MSG do
+    
+    it 'will have methods as attrs' do
+      expect(described_class.new).to respond_to(:hwnd, :message, :wParam, :lParam, :time, :pt)
+    end
+    
+    it %q(will have an size eql to it's layout types sizes) do
+      expect(described_class.new.to_ptr.size).to eql(described_class.size)
+    end
+    
+  end
+  
+  describe described_class::COORD do
+    it_behaves_like 'attributes_and_size_test' do
+      let(:ary) { [:x, :y] }
+      let(:sze) { 4 }
+    end
+  end
+  
+end