From 0ed32396a0fd63625ea94c4da86c2df3829acc72 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Zurcher?= <jeremy@asynk.ch>
Date: Fri, 29 Apr 2011 14:45:08 +0200
Subject: update efl/eina* and specs

---
 lib/efl/eina.rb             |   8 ++
 lib/efl/eina/eina_hash.rb   |  81 -------------------
 lib/efl/eina/eina_list.rb   |  78 -------------------
 lib/efl/eina_hash.rb        |  80 +++++++++++++++++++
 lib/efl/eina_list.rb        |  76 ++++++++++++++++++
 spec/eina/eina_hash_spec.rb | 186 --------------------------------------------
 spec/eina/eina_list_spec.rb | 100 ------------------------
 spec/eina_hash_spec.rb      | 186 ++++++++++++++++++++++++++++++++++++++++++++
 spec/eina_list_spec.rb      | 101 ++++++++++++++++++++++++
 9 files changed, 451 insertions(+), 445 deletions(-)
 delete mode 100644 lib/efl/eina/eina_hash.rb
 delete mode 100644 lib/efl/eina/eina_list.rb
 create mode 100644 lib/efl/eina_hash.rb
 create mode 100644 lib/efl/eina_list.rb
 delete mode 100644 spec/eina/eina_hash_spec.rb
 delete mode 100644 spec/eina/eina_list_spec.rb
 create mode 100644 spec/eina_hash_spec.rb
 create mode 100644 spec/eina_list_spec.rb

diff --git a/lib/efl/eina.rb b/lib/efl/eina.rb
index e5fcc67..dfa266c 100644
--- a/lib/efl/eina.rb
+++ b/lib/efl/eina.rb
@@ -3,4 +3,12 @@
 #
 require 'efl/ffi/eina'
 #
+module Efl
+    #
+    module Eina
+        #
+    end
+    #
+end
+#
 # EOF
diff --git a/lib/efl/eina/eina_hash.rb b/lib/efl/eina/eina_hash.rb
deleted file mode 100644
index 76cd5d2..0000000
--- a/lib/efl/eina/eina_hash.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: UTF-8 -*-
-#
-require 'efl/eina'
-require 'efl/ffi/eina/eina_hash'
-#
-class Hash
-    def self.from_eina_hash o
-        if o.is_a? Efl::Eina::EinaHash
-            o.to_h
-        elsif o.is_a? ::FFI::Pointer
-            Efl::Eina::EinaHash.new(o).to_h
-        else
-            raise ArgumentError.new " wrong argument #{o.class.name}"
-        end
-    end
-end
-module Efl
-    module Eina
-        #
-        class EinaHash
-            include Efl::Helper
-            include Enumerable
-            @func_prefixes = [ 'eina_hash_' ].freeze
-            def initialize o=nil, &block
-                cstr = ( block_given? ? block : Proc.new { Efl::FFI.eina_hash_string_djb2_new ::FFI::Pointer::NULL } )
-                @ptr = (
-                    case o
-                    when ::FFI::Pointer
-                        ( o==::FFI::Pointer::NULL ? cstr.call : o )
-                    when NilClass
-                        cstr.call
-                    when self.class
-                        o.ptr
-                    when Hash
-                        ptr = cstr.call
-                        o.each do |k,v| Efl::FFI.eina_hash_add ptr, k, v end
-                        ptr
-                    else
-                        raise ArgumentError.new "#{ptr.class} valid argument"
-                    end
-                )
-            end
-            def free
-                return if @ptr==::FFI::Pointer::NULL
-                @ptr = Efl::FFI.eina_hash_free @ptr
-            end
-            def each data=::FFI::Pointer::NULL, &block
-                return if not block_given?
-                Efl::FFI::eina_hash_foreach @ptr, Proc.new{|h,k,v,d| block.call(k,v) }, data
-            end
-            def to_h
-                 rh = {}
-                 each { |k,v| rh[k]=v; true }
-                 rh
-            end
-            def to_h_conv &block
-                 rh = {}
-                 if block_given?
-                    each { |k,v| rh[block.call(k)]=v; true }
-                 else
-                    each { |k,v| rh[k.read_string]=v; true }
-                 end
-                 rh
-            end
-            # for fun and tests
-            def add k, v
-                Efl::FFI.eina_hash_add @ptr, k, v
-                v
-            end
-            alias :[]= :add
-            def find k
-                r = Efl::FFI.eina_hash_find @ptr, k
-                return ( r==::FFI::Pointer::NULL ? nil : r )
-            end
-            alias :[] :find
-        end
-    end
-end
-#
-# EOF
diff --git a/lib/efl/eina/eina_list.rb b/lib/efl/eina/eina_list.rb
deleted file mode 100644
index fdbc176..0000000
--- a/lib/efl/eina/eina_list.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: UTF-8 -*-
-#
-require 'efl/eina'
-require 'efl/ffi/eina/eina_list'
-#
-class Array
-    def self.from_eina_list o
-        if o.is_a? Efl::Eina::EinaList
-            o.to_ary
-        elsif o.is_a? ::FFI::Pointer
-            Efl::Eina::EinaList.new(o).to_ary
-        else
-            raise ArgumentError.new " wrong argument #{o.class.name}"
-        end
-    end
-end
-module Efl
-    module FFI
-        class EinaList < ::FFI::Struct
-            layout  :data,          :pointer,
-                    :next,          :pointer,
-                    :prev,          :pointer,
-                    :accounting,    :pointer,
-                    :magic,         :uint,
-        end
-    end
-    module Eina
-        #
-        class EinaList
-            include Efl::Helper
-            include Enumerable
-            @func_prefixes = [ 'eina_list_' ].freeze
-            def initialize o=nil
-                @ptr = (
-                    case o
-                    when ::FFI::Pointer
-                        o
-                    when NilClass
-                        ::FFI::Pointer::NULL
-                    when self.class
-                        o.ptr
-                    when Array
-                        o.inject(::FFI::Pointer::NULL) { |p,e| Efl::FFI::eina_list_append p, e }
-                    else
-                        raise ArgumentError.new "#{ptr.class} valid argument"
-                    end
-                )
-            end
-            def free
-                return if @ptr==::FFI::Pointer::NULL
-                @ptr = Efl::FFI.eina_list_free @ptr
-            end
-            def each
-                p = @ptr
-                while p!=::FFI::Pointer::NULL
-                    l = Efl::FFI::EinaList.new p
-                    yield l[:data]
-                    p = l[:next]
-                end
-            end
-            def to_ary
-                inject([]) { |s,e| s<<e }
-            end
-            # for fun and tests
-            def append p
-                @ptr = Efl::FFI.eina_list_append @ptr, p
-            end
-            alias :<< :append
-            def prepend p
-                @ptr = Efl::FFI.eina_list_prepend @ptr, p
-            end
-            alias :unshift :prepend
-        end
-    end
-end
-#
-# EOF
diff --git a/lib/efl/eina_hash.rb b/lib/efl/eina_hash.rb
new file mode 100644
index 0000000..03619dc
--- /dev/null
+++ b/lib/efl/eina_hash.rb
@@ -0,0 +1,80 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/eina_hash'
+#
+class Hash
+    def self.from_eina_hash o
+        if o.is_a? Efl::EinaHash::REinaHash
+            o.to_h
+        elsif o.is_a? FFI::Pointer
+            Efl::EinaHash::REinaHash.new(o).to_h
+        else
+            raise ArgumentError.new " wrong argument #{o.class.name}"
+        end
+    end
+end
+module Efl
+    module EinaHash
+        #
+        class REinaHash
+            include Enumerable
+            include Efl::ClassHelper
+            @func_prefixes = [ [Efl::EinaHash,'eina_hash_'] ].freeze
+            def initialize o=nil, &block
+                cstr = ( block_given? ? block : Proc.new { Efl::EinaHash.eina_hash_string_djb2_new FFI::Pointer::NULL } )
+                @ptr = (
+                    case o
+                    when FFI::Pointer
+                        ( o==FFI::Pointer::NULL ? cstr.call : o )
+                    when NilClass
+                        cstr.call
+                    when self.class
+                        o.ptr
+                    when Hash
+                        ptr = cstr.call
+                        o.each do |k,v| Efl::EinaHash.eina_hash_add ptr, k, v end
+                        ptr
+                    else
+                        raise ArgumentError.new "#{ptr.class} valid argument"
+                    end
+                )
+            end
+            def free
+                return if @ptr==FFI::Pointer::NULL
+                @ptr = Efl::EinaHash.eina_hash_free @ptr
+            end
+            def each data=FFI::Pointer::NULL, &block
+                return if not block_given?
+                Efl::EinaHash::eina_hash_foreach @ptr, Proc.new{|h,k,v,d| block.call(k,v) }, data
+            end
+            def to_h
+                 rh = {}
+                 each { |k,v| rh[k]=v; true }
+                 rh
+            end
+            def to_h_conv &block
+                 rh = {}
+                 if block_given?
+                    each { |k,v| rh[block.call(k)]=v; true }
+                 else
+                    each { |k,v| rh[k.read_string]=v; true }
+                 end
+                 rh
+            end
+            # for fun and tests
+            def add k, v
+                Efl::EinaHash.eina_hash_add @ptr, k, v
+                v
+            end
+            alias :[]= :add
+            def find k
+                r = Efl::EinaHash.eina_hash_find @ptr, k
+                return ( r==FFI::Pointer::NULL ? nil : r )
+            end
+            alias :[] :find
+        end
+    end
+end
+#
+# EOF
diff --git a/lib/efl/eina_list.rb b/lib/efl/eina_list.rb
new file mode 100644
index 0000000..ecd0e20
--- /dev/null
+++ b/lib/efl/eina_list.rb
@@ -0,0 +1,76 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi/eina_list'
+#
+class Array
+    def self.from_eina_list o
+        if o.is_a? Efl::EinaList::REinaList
+            o.to_ary
+        elsif o.is_a? FFI::Pointer
+            Efl::EinaList::REinaList.new(o).to_ary
+        else
+            raise ArgumentError.new " wrong argument #{o.class.name}"
+        end
+    end
+end
+module Efl
+    module EinaList
+        #
+        class EinaListStruct < FFI::Struct
+            layout  :data,          :pointer,
+                    :next,          :pointer,
+                    :prev,          :pointer,
+                    :accounting,    :pointer,
+                    :magic,         :uint,
+        end
+        #
+        class REinaList
+            include Enumerable
+            include Efl::ClassHelper
+            @search_paths = [ [Efl::EinaList,'eina_list_'] ].freeze
+            def initialize o=nil
+                @ptr = (
+                    case o
+                    when FFI::Pointer
+                        o
+                    when NilClass
+                        FFI::Pointer::NULL
+                    when self.class
+                        o.ptr
+                    when Array
+                        o.inject(FFI::Pointer::NULL) { |p,e| Efl::EinaList.eina_list_append p, e }
+                    else
+                        raise ArgumentError.new "#{ptr.class} valid argument"
+                    end
+                )
+            end
+            def free
+                return if @ptr==FFI::Pointer::NULL
+                @ptr = Efl::EinaList.eina_list_free @ptr
+            end
+            def each
+                p = @ptr
+                while p!=::FFI::Pointer::NULL
+                    l = Efl::EinaList::EinaListStruct.new p
+                    yield l[:data]
+                    p = l[:next]
+                end
+            end
+            def to_ary
+                inject([]) { |s,e| s<<e }
+            end
+            # for fun and tests
+            def append p
+                @ptr = Efl::EinaList.eina_list_append @ptr, p
+            end
+            alias :<< :append
+            def prepend p
+                @ptr = Efl::EinaList.eina_list_prepend @ptr, p
+            end
+            alias :unshift :prepend
+        end
+    end
+end
+#
+# EOF
diff --git a/spec/eina/eina_hash_spec.rb b/spec/eina/eina_hash_spec.rb
deleted file mode 100644
index 3cd5504..0000000
--- a/spec/eina/eina_hash_spec.rb
+++ /dev/null
@@ -1,186 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: UTF-8 -*-
-#
-require 'efl/eina/eina_hash'
-#
-describe Efl::Eina::EinaHash do
-    #
-    before(:all) {
-        EinaHash = Efl::Eina::EinaHash
-        Efl::Eina.init.should eql 1
-        @d0 = ::FFI::MemoryPointer.from_string "D0"
-        @d1 = ::FFI::MemoryPointer.from_string "D1"
-        @d2 = ::FFI::MemoryPointer.from_string "D2"
-        @d3 = ::FFI::MemoryPointer.from_string "D3"
-    }
-    after(:all) {
-        Efl::Eina.shutdown.should eql 0
-    }
-    #
-    it "should append prepend and fetch" do
-        h = EinaHash.new
-        h.add 'k2', @d2
-        h.add 'k1', @d1
-        h['k3']=@d3
-        h['k0']=@d0
-        h['k0'].read_string.should eql "D0"
-        h['k1'].read_string.should eql "D1"
-        h['k2'].read_string.should eql "D2"
-        h['k3'].read_string.should eql "D3"
-        cpt=0
-        h.each { |k,v|
-            cpt+=1
-            v.read_string.empty?.should be_false
-        }
-        cpt.should eql 4
-        h.free
-    end
-    #
-    it "should be able to convert into ruby Hash from NULL pointer" do
-        h = Hash.from_eina_hash ::FFI::Pointer::NULL
-        h.empty?.should be_true
-        h.is_a?(Hash).should be_true
-    end
-    #
-    it "should be able to convert into ruby Hash from empty EinaHash" do
-        h = Hash.from_eina_hash EinaHash.new
-        h.empty?.should be_true
-        h.is_a?(Hash).should be_true
-    end
-    #
-    it "should be able to convert into ruby Hash from empty EinaHash pointer" do
-        h = Hash.from_eina_hash EinaHash.new.ptr
-        h.empty?.should be_true
-        h.is_a?(Hash).should be_true
-    end
-    #
-    it "should be able to convert into ruby Hash from non empty EinaHash" do
-        h = EinaHash.new
-        d0 = ::FFI::MemoryPointer.from_string "D0"
-        d1 = ::FFI::MemoryPointer.from_string "D1"
-        d2 = ::FFI::MemoryPointer.from_string "D2"
-        d3 = ::FFI::MemoryPointer.from_string "D3"
-        h.add 'k2', d2
-        h.add 'k1', d1
-        h['k3']=d3
-        h["k0"]=d0
-        h["k0"].read_string.should eql "D0"
-        h['k1'].read_string.should eql "D1"
-        h['k2'].read_string.should eql "D2"
-        h['k3'].read_string.should eql "D3"
-        cpt=0
-        h.each { |k,v|
-            cpt+=1
-            v.read_string.empty?.should be_false
-            true
-        }
-        cpt.should eql 4
-        rh =  Hash.from_eina_hash h
-        rh.length.should eql 4
-        rh2 = {}
-        rh.each { |k,v|
-            rh2[k.read_string]=v.read_string
-            true
-        }
-        rh2['k0'].should eql 'D0'
-        rh2['k1'].should eql 'D1'
-        rh2['k2'].should eql 'D2'
-        rh2['k3'].should eql 'D3'
-        h.free
-    end
-    #
-    it "should be able to convert into ruby Hash from non empty EinaHash pointer" do
-        h = EinaHash.new
-        d0 = ::FFI::MemoryPointer.from_string "D0"
-        d1 = ::FFI::MemoryPointer.from_string "D1"
-        d2 = ::FFI::MemoryPointer.from_string "D2"
-        d3 = ::FFI::MemoryPointer.from_string "D3"
-        h.add 'k2', d2
-        h.add 'k1', d1
-        h['k3']=d3
-        h['k0']=d0
-        h['k0'].read_string.should eql "D0"
-        h['k1'].read_string.should eql "D1"
-        h['k2'].read_string.should eql "D2"
-        h['k3'].read_string.should eql "D3"
-        rh =  Hash.from_eina_hash h.ptr
-        rh.length.should eql 4
-        h.free
-    end
-    #
-    it "should be able to convert into ruby Hash from non empty EinaHash pointer, with key from string" do
-        h = EinaHash.new
-        d0 = ::FFI::MemoryPointer.from_string "D0"
-        d1 = ::FFI::MemoryPointer.from_string "D1"
-        d2 = ::FFI::MemoryPointer.from_string "D2"
-        d3 = ::FFI::MemoryPointer.from_string "D3"
-        h.add 'k2', d2
-        h.add 'k1', d1
-        h['k3']=d3
-        h['k0']=d0
-        h['k0'].read_string.should eql "D0"
-        h['k1'].read_string.should eql "D1"
-        h['k2'].read_string.should eql "D2"
-        h['k3'].read_string.should eql "D3"
-        rh =  h.to_h_conv
-        rh.length.should eql 4
-        rh['k0'].read_string.should eql "D0"
-        rh['k1'].read_string.should eql "D1"
-        rh['k2'].read_string.should eql "D2"
-        rh['k3'].read_string.should eql "D3"
-        h.free
-    end
-    #
-    it "should be able to convert into ruby Hash from non empty EinaHash pointer, with key from string block" do
-        h = EinaHash.new
-        d0 = ::FFI::MemoryPointer.from_string "D0"
-        d1 = ::FFI::MemoryPointer.from_string "D1"
-        d2 = ::FFI::MemoryPointer.from_string "D2"
-        d3 = ::FFI::MemoryPointer.from_string "D3"
-        h.add 'k2', d2
-        h.add 'k1', d1
-        h['k3']=d3
-        h['k0']=d0
-        h['k0'].read_string.should eql "D0"
-        h['k1'].read_string.should eql "D1"
-        h['k2'].read_string.should eql "D2"
-        h['k3'].read_string.should eql "D3"
-        cpt=0
-        rh =  h.to_h_conv { |k| cpt+=1; k.read_string }
-        cpt.should eql 4
-        rh.length.should eql 4
-        rh['k0'].read_string.should eql "D0"
-        rh['k1'].read_string.should eql "D1"
-        rh['k2'].read_string.should eql "D2"
-        rh['k3'].read_string.should eql "D3"
-        h.free
-    end
-    #
-    it "should be able to build from ruby Hash" do
-        rh = {}
-        k0 = ::FFI::MemoryPointer.from_string "0"
-        k1 = ::FFI::MemoryPointer.from_string "1"
-        k2 = ::FFI::MemoryPointer.from_string "2"
-        k3 = ::FFI::MemoryPointer.from_string "3"
-        d0 = ::FFI::MemoryPointer.from_string "D0"
-        d1 = ::FFI::MemoryPointer.from_string "D1"
-        d2 = ::FFI::MemoryPointer.from_string "D2"
-        d3 = ::FFI::MemoryPointer.from_string "D3"
-        rh[k0]=d0
-        rh[k1]=d1
-        rh[k2]=d2
-        rh[k3]=d3
-        h = EinaHash.new rh
-        h[k0].read_string.should eql "D0"
-        h[k1].read_string.should eql "D1"
-        h[k2].read_string.should eql "D2"
-        h[k3].read_string.should eql "D3"
-        h.free
-    end
-    #
-    it "alternate constructor should work" do
-        cstr_cnt = 0
-        h = EinaHash.new { cstr_cnt+=1; Efl::FFI.eina_hash_string_superfast_new ::FFI::Pointer::NULL }
-        cstr_cnt.should eql 1
-    end
-end
diff --git a/spec/eina/eina_list_spec.rb b/spec/eina/eina_list_spec.rb
deleted file mode 100644
index 2522256..0000000
--- a/spec/eina/eina_list_spec.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: UTF-8 -*-
-#
-require 'efl/eina/eina_list'
-#
-describe Efl::Eina::EinaList do
-    #
-    before(:all) {
-        EinaList = Efl::Eina::EinaList
-        Efl::Eina.init.should eql 1
-    }
-    after(:all) {
-        Efl::Eina.shutdown.should eql 0
-    }
-    #
-    it "should append prepend and fetch" do
-        l = EinaList.new
-        d1 = ::FFI::MemoryPointer.from_string "D0"
-        d2 = ::FFI::MemoryPointer.from_string "D1"
-        d3 = ::FFI::MemoryPointer.from_string "D2"
-        d4 = ::FFI::MemoryPointer.from_string "D3"
-        l.append d3
-        l.prepend d2
-        l << d4
-        l.unshift d1
-        0.upto 3 do |i|
-            l.nth(i).read_string.should eql "D#{i}"
-        end
-        l.each { |p| p.read_string.empty?.should be_false }
-        l.free
-    end
-    #
-    it "should be able to convert into ruby Array from NULL pointer" do
-        ary = Array.from_eina_list ::FFI::Pointer::NULL
-        ary.empty?.should be_true
-        ary.is_a?(Array).should be_true
-    end
-    #
-    it "should be able to convert into ruby Array from empty EinaList" do
-        ary = Array.from_eina_list EinaList.new
-        ary.empty?.should be_true
-        ary.is_a?(Array).should be_true
-    end
-    #
-    it "should be able to convert into ruby Array from empty EinaList pointer" do
-        ary = Array.from_eina_list EinaList.new.ptr
-        ary.empty?.should be_true
-        ary.is_a?(Array).should be_true
-    end
-    #
-    it "should be able to convert into ruby Array from non empty EinaList" do
-        l = EinaList.new
-        d1 = ::FFI::MemoryPointer.from_string "D0"
-        d2 = ::FFI::MemoryPointer.from_string "D1"
-        d3 = ::FFI::MemoryPointer.from_string "D2"
-        d4 = ::FFI::MemoryPointer.from_string "D3"
-        l.append d3
-        l.prepend d2
-        l << d4
-        l.unshift d1
-        ary =  Array.from_eina_list l
-        ary.length.should eql 4
-        0.upto 3 do |i|
-            ary[i].read_string.should eql "D#{i}"
-        end
-        l.free
-    end
-    #
-    it "should be able to convert into ruby Array from non empty EinaList pointer" do
-        l = EinaList.new
-        d1 = ::FFI::MemoryPointer.from_string "D0"
-        d2 = ::FFI::MemoryPointer.from_string "D1"
-        d3 = ::FFI::MemoryPointer.from_string "D2"
-        d4 = ::FFI::MemoryPointer.from_string "D3"
-        l.append d3
-        l.prepend d2
-        l << d4
-        l.unshift d1
-        ary =  Array.from_eina_list l.ptr
-        ary.length.should eql 4
-        0.upto 3 do |i|
-            ary[i].read_string.should eql "D#{i}"
-        end
-        l.free
-    end
-    #
-    it "should be able to build from ruby Array" do
-        a =  []
-        a << ::FFI::MemoryPointer.from_string("D0")
-        a << ::FFI::MemoryPointer.from_string("D1")
-        a << ::FFI::MemoryPointer.from_string("D2")
-        a << ::FFI::MemoryPointer.from_string("D3")
-        l = EinaList.new a
-        0.upto 3 do |i|
-            l.nth(i).read_string.should eql "D#{i}"
-        end
-        l.free
-    end
-    #
-end
diff --git a/spec/eina_hash_spec.rb b/spec/eina_hash_spec.rb
new file mode 100644
index 0000000..5efc062
--- /dev/null
+++ b/spec/eina_hash_spec.rb
@@ -0,0 +1,186 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/eina_hash'
+#
+describe Efl::EinaHash do
+    #
+    before(:all) {
+        REinaHash = Efl::EinaHash::REinaHash
+        Efl::Eina.init.should eql 1
+        @d0 = FFI::MemoryPointer.from_string "D0"
+        @d1 = FFI::MemoryPointer.from_string "D1"
+        @d2 = FFI::MemoryPointer.from_string "D2"
+        @d3 = FFI::MemoryPointer.from_string "D3"
+    }
+    after(:all) {
+        Efl::Eina.shutdown.should eql 0
+    }
+    #
+    it "should append prepend and fetch" do
+        h = REinaHash.new
+        h.add 'k2', @d2
+        h.add 'k1', @d1
+        h['k3']=@d3
+        h['k0']=@d0
+        h['k0'].read_string.should eql "D0"
+        h['k1'].read_string.should eql "D1"
+        h['k2'].read_string.should eql "D2"
+        h['k3'].read_string.should eql "D3"
+        cpt=0
+        h.each { |k,v|
+            cpt+=1
+            v.read_string.empty?.should be_false
+        }
+        cpt.should eql 4
+        h.free
+    end
+    #
+    it "should be able to convert into ruby Hash from NULL pointer" do
+        h = Hash.from_eina_hash FFI::Pointer::NULL
+        h.empty?.should be_true
+        h.is_a?(Hash).should be_true
+    end
+    #
+    it "should be able to convert into ruby Hash from empty REinaHash" do
+        h = Hash.from_eina_hash REinaHash.new
+        h.empty?.should be_true
+        h.is_a?(Hash).should be_true
+    end
+    #
+    it "should be able to convert into ruby Hash from empty REinaHash pointer" do
+        h = Hash.from_eina_hash REinaHash.new.to_ptr
+        h.empty?.should be_true
+        h.is_a?(Hash).should be_true
+    end
+    #
+    it "should be able to convert into ruby Hash from non empty REinaHash" do
+        h = REinaHash.new
+        d0 = FFI::MemoryPointer.from_string "D0"
+        d1 = FFI::MemoryPointer.from_string "D1"
+        d2 = FFI::MemoryPointer.from_string "D2"
+        d3 = FFI::MemoryPointer.from_string "D3"
+        h.add 'k2', d2
+        h.add 'k1', d1
+        h['k3']=d3
+        h["k0"]=d0
+        h["k0"].read_string.should eql "D0"
+        h['k1'].read_string.should eql "D1"
+        h['k2'].read_string.should eql "D2"
+        h['k3'].read_string.should eql "D3"
+        cpt=0
+        h.each { |k,v|
+            cpt+=1
+            v.read_string.empty?.should be_false
+            true
+        }
+        cpt.should eql 4
+        rh =  Hash.from_eina_hash h
+        rh.length.should eql 4
+        rh2 = {}
+        rh.each { |k,v|
+            rh2[k.read_string]=v.read_string
+            true
+        }
+        rh2['k0'].should eql 'D0'
+        rh2['k1'].should eql 'D1'
+        rh2['k2'].should eql 'D2'
+        rh2['k3'].should eql 'D3'
+        h.free
+    end
+    #
+    it "should be able to convert into ruby Hash from non empty REinaHash pointer" do
+        h = REinaHash.new
+        d0 = FFI::MemoryPointer.from_string "D0"
+        d1 = FFI::MemoryPointer.from_string "D1"
+        d2 = FFI::MemoryPointer.from_string "D2"
+        d3 = FFI::MemoryPointer.from_string "D3"
+        h.add 'k2', d2
+        h.add 'k1', d1
+        h['k3']=d3
+        h['k0']=d0
+        h['k0'].read_string.should eql "D0"
+        h['k1'].read_string.should eql "D1"
+        h['k2'].read_string.should eql "D2"
+        h['k3'].read_string.should eql "D3"
+        rh =  Hash.from_eina_hash h.to_ptr
+        rh.length.should eql 4
+        h.free
+    end
+    #
+    it "should be able to convert into ruby Hash from non empty REinaHash pointer, with key from string" do
+        h = REinaHash.new
+        d0 = FFI::MemoryPointer.from_string "D0"
+        d1 = FFI::MemoryPointer.from_string "D1"
+        d2 = FFI::MemoryPointer.from_string "D2"
+        d3 = FFI::MemoryPointer.from_string "D3"
+        h.add 'k2', d2
+        h.add 'k1', d1
+        h['k3']=d3
+        h['k0']=d0
+        h['k0'].read_string.should eql "D0"
+        h['k1'].read_string.should eql "D1"
+        h['k2'].read_string.should eql "D2"
+        h['k3'].read_string.should eql "D3"
+        rh =  h.to_h_conv
+        rh.length.should eql 4
+        rh['k0'].read_string.should eql "D0"
+        rh['k1'].read_string.should eql "D1"
+        rh['k2'].read_string.should eql "D2"
+        rh['k3'].read_string.should eql "D3"
+        h.free
+    end
+    #
+    it "should be able to convert into ruby Hash from non empty REinaHash pointer, with key from string block" do
+        h = REinaHash.new
+        d0 = FFI::MemoryPointer.from_string "D0"
+        d1 = FFI::MemoryPointer.from_string "D1"
+        d2 = FFI::MemoryPointer.from_string "D2"
+        d3 = FFI::MemoryPointer.from_string "D3"
+        h.add 'k2', d2
+        h.add 'k1', d1
+        h['k3']=d3
+        h['k0']=d0
+        h['k0'].read_string.should eql "D0"
+        h['k1'].read_string.should eql "D1"
+        h['k2'].read_string.should eql "D2"
+        h['k3'].read_string.should eql "D3"
+        cpt=0
+        rh =  h.to_h_conv { |k| cpt+=1; k.read_string }
+        cpt.should eql 4
+        rh.length.should eql 4
+        rh['k0'].read_string.should eql "D0"
+        rh['k1'].read_string.should eql "D1"
+        rh['k2'].read_string.should eql "D2"
+        rh['k3'].read_string.should eql "D3"
+        h.free
+    end
+    #
+    it "should be able to build from ruby Hash" do
+        rh = {}
+        k0 = FFI::MemoryPointer.from_string "0"
+        k1 = FFI::MemoryPointer.from_string "1"
+        k2 = FFI::MemoryPointer.from_string "2"
+        k3 = FFI::MemoryPointer.from_string "3"
+        d0 = FFI::MemoryPointer.from_string "D0"
+        d1 = FFI::MemoryPointer.from_string "D1"
+        d2 = FFI::MemoryPointer.from_string "D2"
+        d3 = FFI::MemoryPointer.from_string "D3"
+        rh[k0]=d0
+        rh[k1]=d1
+        rh[k2]=d2
+        rh[k3]=d3
+        h = REinaHash.new rh
+        h[k0].read_string.should eql "D0"
+        h[k1].read_string.should eql "D1"
+        h[k2].read_string.should eql "D2"
+        h[k3].read_string.should eql "D3"
+        h.free
+    end
+    #
+    it "alternate constructor should work" do
+        cstr_cnt = 0
+        h = REinaHash.new { cstr_cnt+=1; Efl::EinaHash.eina_hash_string_superfast_new FFI::Pointer::NULL }
+        cstr_cnt.should eql 1
+    end
+end
diff --git a/spec/eina_list_spec.rb b/spec/eina_list_spec.rb
new file mode 100644
index 0000000..74f89c5
--- /dev/null
+++ b/spec/eina_list_spec.rb
@@ -0,0 +1,101 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/eina'
+require 'efl/eina_list'
+#
+describe Efl::EinaList do
+    #
+    before(:all) {
+        REinaList = Efl::EinaList::REinaList
+        Efl::Eina.init.should eql 1
+    }
+    after(:all) {
+        Efl::Eina.shutdown.should eql 0
+    }
+    #
+    it "should append prepend and fetch" do
+        l = REinaList.new
+        d1 = ::FFI::MemoryPointer.from_string "D0"
+        d2 = ::FFI::MemoryPointer.from_string "D1"
+        d3 = ::FFI::MemoryPointer.from_string "D2"
+        d4 = ::FFI::MemoryPointer.from_string "D3"
+        l.append d3
+        l.prepend d2
+        l << d4
+        l.unshift d1
+        0.upto 3 do |i|
+            l.nth(i).read_string.should eql "D#{i}"
+        end
+        l.each { |p| p.read_string.empty?.should be_false }
+        l.free
+    end
+    #
+    it "should be able to convert into ruby Array from NULL pointer" do
+        ary = Array.from_eina_list ::FFI::Pointer::NULL
+        ary.empty?.should be_true
+        ary.is_a?(Array).should be_true
+    end
+    #
+    it "should be able to convert into ruby Array from empty REinaList" do
+        ary = Array.from_eina_list REinaList.new
+        ary.empty?.should be_true
+        ary.is_a?(Array).should be_true
+    end
+    #
+    it "should be able to convert into ruby Array from empty REinaList pointer" do
+        ary = Array.from_eina_list REinaList.new.to_ptr
+        ary.empty?.should be_true
+        ary.is_a?(Array).should be_true
+    end
+    #
+    it "should be able to convert into ruby Array from non empty REinaList" do
+        l = REinaList.new
+        d1 = ::FFI::MemoryPointer.from_string "D0"
+        d2 = ::FFI::MemoryPointer.from_string "D1"
+        d3 = ::FFI::MemoryPointer.from_string "D2"
+        d4 = ::FFI::MemoryPointer.from_string "D3"
+        l.append d3
+        l.prepend d2
+        l << d4
+        l.unshift d1
+        ary =  Array.from_eina_list l
+        ary.length.should eql 4
+        0.upto 3 do |i|
+            ary[i].read_string.should eql "D#{i}"
+        end
+        l.free
+    end
+    #
+    it "should be able to convert into ruby Array from non empty REinaList pointer" do
+        l = REinaList.new
+        d1 = ::FFI::MemoryPointer.from_string "D0"
+        d2 = ::FFI::MemoryPointer.from_string "D1"
+        d3 = ::FFI::MemoryPointer.from_string "D2"
+        d4 = ::FFI::MemoryPointer.from_string "D3"
+        l.append d3
+        l.prepend d2
+        l << d4
+        l.unshift d1
+        ary =  Array.from_eina_list l.to_ptr
+        ary.length.should eql 4
+        0.upto 3 do |i|
+            ary[i].read_string.should eql "D#{i}"
+        end
+        l.free
+    end
+    #
+    it "should be able to build from ruby Array" do
+        a =  []
+        a << ::FFI::MemoryPointer.from_string("D0")
+        a << ::FFI::MemoryPointer.from_string("D1")
+        a << ::FFI::MemoryPointer.from_string("D2")
+        a << ::FFI::MemoryPointer.from_string("D3")
+        l = REinaList.new a
+        0.upto 3 do |i|
+            l.nth(i).read_string.should eql "D#{i}"
+        end
+        l.free
+    end
+    #
+end
-- 
cgit v1.1-2-g2b99