ffi-efl 0.0.3 → 0.0.4

data/spec/ecore_spec.rb

@@ -8,129 +8,107 @@ describe Efl::Ecore do
     before(:all) do
         Ecore = Efl::Ecore
         USER_SIGNAL_CB = Proc.new do |data, type, event|
-            data.read_string.should eql "ok"
-            type.should eql Ecore::EVENT_SIGNAL_USER
-            event.read_int.should eql 666
-            Ecore.event_current_type_get.should eql Ecore::EVENT_SIGNAL_USER
-            Ecore.event_current_event_get.address.should eql event.address
+            data.read_string.should == "ok"
+            type.should == Ecore::EVENT_SIGNAL_USER
+            event.read_int.should == 666
+            Ecore.event_current_type_get.should == Ecore::EVENT_SIGNAL_USER
+            Ecore.event_current_event_get.address.should == event.address
             Ecore.main_loop_quit
         end
         EVENT_FREE_CB = Proc.new do |data,event|
-            data.read_string.should eql "none"
-            event.read_int.should eql 666
+            data.read_string.should == "none"
+            event.read_int.should == 666
         end
         OK = FFI::MemoryPointer.from_string "ok"
         KO = FFI::MemoryPointer.from_string "ko"
         NONE = FFI::MemoryPointer.from_string "none"
     end
+    before(:each) {
+        Ecore.init
+    }
+    after(:each) {
+        Ecore.shutdown
+    }
     #
     it "should init" do
-        Ecore.init.should eql 1
-        Ecore.init.should eql 2
-        Ecore.init.should eql 3
+        Ecore.init.should == 2
+        Ecore.init.should == 3
     end
     #
     it "should shutdown" do
-        Ecore.shutdown.should eql 2
-        Ecore.shutdown.should eql 1
-        Ecore.shutdown.should eql 0
+        Ecore.shutdown.should == 2
+        Ecore.shutdown.should == 1
     end
     #
     it "should run a single iteration of the mainloop" do
-        Ecore.init
-        Ecore.main_loop_iterate
-        Ecore.shutdown
-    end
-    #
-    it 'should write and read data from pipe' do
-        data = FFI::MemoryPointer.from_string("none")
-        cb = Proc.new do |data,buffer,bytes|
-            data.read_string.should eql 'none'
-            buffer.read_string.should eql 'hello world'
-            bytes.should eql 12
-        end
-        Ecore.init
-        pipe = Ecore::REcorePipe.new cb, data
-        pipe.write("hello world").should be_true
         Ecore.main_loop_iterate
-        pipe.read_close
-        pipe.write_close
-        pipe.del.address.should eql data.address
-        Ecore.shutdown
     end
     #
     it 'should be able to add, del event hanlder and process event' do
-        Ecore.init
         evt = FFI::MemoryPointer.new(:int)
         evt.write_int 666
         # add, del, add event handler
         evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, KO
         evt_handler.null?.should be_false
-        Ecore.event_handler_del(evt_handler).address.should eql KO.address
+        Ecore.event_handler_del(evt_handler).address.should == KO.address
         evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, OK
         evt_handler.null?.should be_false
         # add, del, add event
         ecore_evt = Ecore.event_add Ecore::EVENT_SIGNAL_USER, evt, EVENT_FREE_CB, NONE
         ecore_evt.null?.should be_false
-        Ecore.event_del(ecore_evt).address.should eql NONE.address
+        Ecore.event_del(ecore_evt).address.should == NONE.address
         ecore_evt = Ecore.event_add Ecore::EVENT_SIGNAL_USER, evt, EVENT_FREE_CB, NONE
         ecore_evt.null?.should be_false
         Ecore.main_loop_begin   # process event
-        Ecore.shutdown
     end
     #
     it "should be able to get and set event handler data" do
-        Ecore.init
         evt = FFI::MemoryPointer.new(:int)
         evt.write_int 666
         evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, KO
         evt_handler.null?.should be_false
-        Ecore.event_handler_data_get(evt_handler).read_string.should eql "ko"
-        Ecore.event_handler_data_set(evt_handler, OK).address.should eql KO.address
-        Ecore.event_handler_data_get(evt_handler).read_string.should eql "ok"
+        Ecore.event_handler_data_get(evt_handler).read_string.should == "ko"
+        Ecore.event_handler_data_set(evt_handler, OK).address.should == KO.address
+        Ecore.event_handler_data_get(evt_handler).read_string.should == "ok"
         ecore_evt = Ecore.event_add Ecore::EVENT_SIGNAL_USER, evt, EVENT_FREE_CB, NONE
         ecore_evt.null?.should be_false
         Ecore.main_loop_begin   # process event
-        Ecore.shutdown
     end
     #
     it "should be able to create new event type" do
-        Ecore.init
-        Ecore.event_type_new.should_not eql 0
-        Ecore.event_type_new.should_not eql 0
-        Ecore.event_type_new.should_not eql 0
-        Ecore.shutdown
+        Ecore.event_type_new.should_not == 0
+        Ecore.event_type_new.should_not == 0
+        Ecore.event_type_new.should_not == 0
     end
     #
     it "should be possible to add and del event filters" do
-        Ecore.init
         loop_data = FFI::MemoryPointer.from_string("loop_data")
         event_free_cb = Proc.new do |data,event|
-            data.read_string.should eql "ko"
-            event.read_int.should eql 69
+            data.read_string.should == "ko"
+            event.read_int.should == 69
         end
         start_cb = Proc.new do |data|
-            data.read_string.should eql "ok"
+            data.read_string.should == "ok"
             loop_data
         end
         count = 0
         filter_cb = Proc.new do |data,loop_data,type,event|
-            data.read_string.should eql "ok"
-            loop_data.read_string.should eql "loop_data"
-            type.should eql Ecore::EVENT_SIGNAL_USER
+            data.read_string.should == "ok"
+            loop_data.read_string.should == "loop_data"
+            type.should == Ecore::EVENT_SIGNAL_USER
             count += 1
             if event.read_int == 69
-                count.should eql 1
+                count.should == 1
                 false   # drop first event
             else
-                count.should eql 2
-                event.read_int.should eql 666
+                count.should == 2
+                event.read_int.should == 666
                 true
             end
         end
         end_cb = Proc.new do |data,loop_data|
-            data.read_string.should eql "ok"
-            loop_data.read_string.should eql "loop_data"
+            data.read_string.should == "ok"
+            loop_data.read_string.should == "loop_data"
         end
         filter = Ecore.event_filter_add start_cb, filter_cb, end_cb, OK
         Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, OK
@@ -141,10 +119,35 @@ describe Efl::Ecore do
         e2.write_int 666
         evt2 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e2, EVENT_FREE_CB, NONE
         Ecore.main_loop_begin   # process event
-        Ecore.event_filter_del(filter).address.should eql OK.address
+        Ecore.event_filter_del(filter).address.should == OK.address
         evt2 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e2, EVENT_FREE_CB, NONE
         Ecore.main_loop_begin   # process event
-        Ecore.shutdown
     end
     #
+    describe Efl::Ecore::REcorePipe do
+    #
+        it 'should write and read data from pipe' do
+            data = FFI::MemoryPointer.from_string("none")
+            cb = Proc.new do |data,buffer,bytes|
+                data.read_string.should == 'none'
+                buffer.read_string.should == 'hello world'
+                bytes.should == 12
+            end
+            pipe = Ecore::REcorePipe.new cb, data
+            pipe.write("hello world").should be_true
+            Ecore.main_loop_iterate
+            pipe.read_close
+            pipe.write_close
+        end
+        it "manual destructor should not raise FFI::AutoPointer error" do
+            data = FFI::MemoryPointer.from_string("none")
+            cb = Proc.new do |data,buffer,bytes|
+                data.read_string.should == 'none'
+                buffer.read_string.should == 'hello world'
+                bytes.should == 12
+            end
+            pipe = Ecore::REcorePipe.new cb, data
+            pipe.del
+        end
+    end
 end

data/spec/edje_spec.rb

@@ -8,15 +8,15 @@ describe Efl::Edje do
     before(:all) { Edje = Efl::Edje }
     #
     it "should init" do
-        Edje.init.should eql 1
-        Edje.init.should eql 2
-        Edje.init.should eql 3
+        Edje.init.should == 1
+        Edje.init.should == 2
+        Edje.init.should == 3
     end
     #
     it "should shutdown" do
-        Edje.shutdown.should eql 2
-        Edje.shutdown.should eql 1
-        Edje.shutdown.should eql 0
+        Edje.shutdown.should == 2
+        Edje.shutdown.should == 1
+        Edje.shutdown.should == 0
     end
     #
 end

data/spec/eet_spec.rb

@@ -7,21 +7,22 @@ describe Efl::Eet do
     #
     before(:all) {
         Eet = Efl::Eet
+        Native = Efl::Native
         REetFile = Efl::Eet::REetFile
     }
     #
     FP = '/tmp/_eet.cfg'
     #
     it "should init" do
-        Eet.init.should eql 1
-        Eet.init.should eql 2
-        Eet.init.should eql 3
+        Eet.init.should == 1
+        Eet.init.should == 2
+        Eet.init.should == 3
     end
     #
     it "should shutdown" do
-        Eet.shutdown.should eql 2
-        Eet.shutdown.should eql 1
-        Eet.shutdown.should eql 0
+        Eet.shutdown.should == 2
+        Eet.shutdown.should == 1
+        Eet.shutdown.should == 0
     end
     #
     it "should clearcache" do
@@ -31,10 +32,10 @@ describe Efl::Eet do
     end
     #
     it "should have good enums" do
-        Eet.enum_type(:eet_file_mode)[:eet_file_mode_invalid].should eql -1
-        Eet.enum_type(:eet_file_mode)[:eet_file_mode_read].should eql 0
-        Eet.enum_type(:eet_file_mode)[:eet_file_mode_write].should eql 1
-        Eet.enum_type(:eet_file_mode)[:eet_file_mode_read_write].should eql 2
+        Native.enum_type(:eet_file_mode)[:eet_file_mode_invalid].should == -1
+        Native.enum_type(:eet_file_mode)[:eet_file_mode_read].should == 0
+        Native.enum_type(:eet_file_mode)[:eet_file_mode_write].should == 1
+        Native.enum_type(:eet_file_mode)[:eet_file_mode_read_write].should == 2
     end
     #
     describe Efl::Eet::REetFile do
@@ -42,45 +43,45 @@ describe Efl::Eet do
         after(:each) { Eet.shutdown }
         #
         it "should open and close" do
-            f = REetFile.open FP, Eet.enum_type(:eet_file_mode)[:eet_file_mode_write]
+            f = REetFile.open FP, Native.enum_type(:eet_file_mode)[:eet_file_mode_write]
             f.write 'fake', 'value'
             f.close
         end
         #
         it "should be able to get file access mode" do
-            Eet.enum_type(:eet_file_mode).symbols.each do |m|
+            Native.enum_type(:eet_file_mode).symbols.each do |m|
                 next if m==:eet_file_mode_invalid
-                REetFile.open FP, Eet.enum_type(:eet_file_mode)[m] do |f|
-                    f.mode_get.should eql m
+                REetFile.open FP, Native.enum_type(:eet_file_mode)[m] do |f|
+                    f.mode_get.should == m
                 end
             end
         end
         #
         it "should write" do
             f = REetFile.open FP, :eet_file_mode_write
-            f.mode_get.should eql :eet_file_mode_write
+            f.mode.should == :eet_file_mode_write
             f.write 'config', 'test key'
             f.close
         end
         #
         it "default mode should be read" do
             f = REetFile.open FP
-            f.mode_get.should eql :eet_file_mode_read
+            f.mode.should == :eet_file_mode_read
             f.close
         end
         #
         it "should read" do
             f = REetFile.open FP, :eet_file_mode_read
-            f.mode_get.should eql :eet_file_mode_read
-            f.read('config').should eql 'test key'
+            f.mode_get.should == :eet_file_mode_read
+            f.read('config').should == 'test key'
             f.close
         end
         #
         it "should read/write" do
             f = REetFile.open FP, :eet_file_mode_read_write
             f.write 'configg', 'test key'
-            f.read('configg').should eql 'test key'
-            f.close
+            f.read('configg').should == 'test key'
+#            f.close    #leave it to FFI::AutoPointer
         end
         #
         it "should write in block" do
@@ -91,14 +92,14 @@ describe Efl::Eet do
         #
         it "should read in block" do
             REetFile.open FP, :eet_file_mode_read do |f|
-                f.read('config2').should eql 'test--key'
+                f.read('config2').should == 'test--key'
             end
         end
         #
         it "should read/write in block" do
             REetFile.open FP, :eet_file_mode_read_write do |f|
                 f.write 'config22', 'test--key'
-                f.read('config22').should eql 'test--key'
+                f.read('config22').should == 'test--key'
             end
         end
         #

data/spec/eina_hash_spec.rb

@@ -1,20 +1,21 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
+require 'efl'
 require 'efl/eina_hash'
 #
 describe Efl::EinaHash do
     #
     before(:all) {
         REinaHash = Efl::EinaHash::REinaHash
-        Efl::Eina.init.should eql 1
+        Efl::Eina.init.should == 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
+        Efl::Eina.shutdown.should == 0
     }
     #
     it "should append prepend and fetch" do
@@ -23,32 +24,26 @@ describe Efl::EinaHash do
         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"
+        h['k0'].read_string.should == "D0"
+        h['k1'].read_string.should == "D1"
+        h['k2'].read_string.should == "D2"
+        h['k3'].read_string.should == "D3"
         cpt=0
         h.each { |k,v|
             cpt+=1
             v.read_string.empty?.should be_false
         }
-        cpt.should eql 4
+        cpt.should == 4
     end
     #
     it "should be able to convert into ruby Hash from NULL pointer" do
-        h = Hash.from_eina_hash FFI::Pointer::NULL
+        h = REinaHash.new(FFI::Pointer::NULL).to_h
         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 = REinaHash.new(FFI::Pointer::NULL).to_h
         h.empty?.should be_true
         h.is_a?(Hash).should be_true
     end
@@ -63,28 +58,28 @@ describe Efl::EinaHash do
         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"
+        h["k0"].read_string.should == "D0"
+        h['k1'].read_string.should == "D1"
+        h['k2'].read_string.should == "D2"
+        h['k3'].read_string.should == "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
+        cpt.should == 4
+        rh = h.to_h
+        rh.length.should == 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'
+        rh2['k0'].should == 'D0'
+        rh2['k1'].should == 'D1'
+        rh2['k2'].should == 'D2'
+        rh2['k3'].should == 'D3'
     end
     #
     it "should be able to convert into ruby Hash from non empty REinaHash pointer" do
@@ -97,12 +92,12 @@ describe Efl::EinaHash do
         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['k0'].read_string.should == "D0"
+        h['k1'].read_string.should == "D1"
+        h['k2'].read_string.should == "D2"
+        h['k3'].read_string.should == "D3"
+        rh = h.to_h
+        rh.length.should == 4
     end
     #
     it "should be able to convert into ruby Hash from non empty REinaHash pointer, with key from string" do
@@ -115,16 +110,16 @@ describe Efl::EinaHash do
         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"
+        h['k0'].read_string.should == "D0"
+        h['k1'].read_string.should == "D1"
+        h['k2'].read_string.should == "D2"
+        h['k3'].read_string.should == "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"
+        rh.length.should == 4
+        rh['k0'].read_string.should == "D0"
+        rh['k1'].read_string.should == "D1"
+        rh['k2'].read_string.should == "D2"
+        rh['k3'].read_string.should == "D3"
     end
     #
     it "should be able to convert into ruby Hash from non empty REinaHash pointer, with key from string block" do
@@ -137,21 +132,21 @@ describe Efl::EinaHash do
         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"
+        h['k0'].read_string.should == "D0"
+        h['k1'].read_string.should == "D1"
+        h['k2'].read_string.should == "D2"
+        h['k3'].read_string.should == "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"
+        cpt.should == 4
+        rh.length.should == 4
+        rh['k0'].read_string.should == "D0"
+        rh['k1'].read_string.should == "D1"
+        rh['k2'].read_string.should == "D2"
+        rh['k3'].read_string.should == "D3"
     end
     #
-    it "should be able to build from ruby Hash" do
+    it "should be able to build REinaHash from ruby Hash" do
         rh = {}
         k0 = FFI::MemoryPointer.from_string "0"
         k1 = FFI::MemoryPointer.from_string "1"
@@ -166,15 +161,15 @@ describe Efl::EinaHash do
         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[k0].read_string.should == "D0"
+        h[k1].read_string.should == "D1"
+        h[k2].read_string.should == "D2"
+        h[k3].read_string.should == "D3"
     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
+        h = REinaHash.new { cstr_cnt+=1; Efl::Native.eina_hash_string_superfast_new FFI::Pointer::NULL }
+        cstr_cnt.should == 1
     end
 end

data/spec/eina_list_spec.rb

@@ -8,10 +8,10 @@ describe Efl::EinaList do
     #
     before(:all) {
         REinaList = Efl::EinaList::REinaList
-        Efl::Eina.init.should eql 1
+        Efl::Eina.init.should == 1
     }
     after(:all) {
-        Efl::Eina.shutdown.should eql 0
+        Efl::Eina.shutdown.should == 0
     }
     #
     it "should append prepend and fetch" do
@@ -25,26 +25,20 @@ describe Efl::EinaList do
         l << d4
         l.unshift d1
         0.upto 3 do |i|
-            l.nth(i).read_string.should eql "D#{i}"
+            l.nth(i).read_string.should == "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 = REinaList.new(FFI::Pointer::NULL).to_ary
         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 = REinaList.new.to_ary
         ary.empty?.should be_true
         ary.is_a?(Array).should be_true
     end
@@ -59,10 +53,10 @@ describe Efl::EinaList do
         l.prepend d2
         l << d4
         l.unshift d1
-        ary =  Array.from_eina_list l
-        ary.length.should eql 4
+        ary = l.to_ary
+        ary.length.should == 4
         0.upto 3 do |i|
-            ary[i].read_string.should eql "D#{i}"
+            ary[i].read_string.should == "D#{i}"
         end
         l.free
     end
@@ -77,10 +71,10 @@ describe Efl::EinaList do
         l.prepend d2
         l << d4
         l.unshift d1
-        ary =  Array.from_eina_list l.to_ptr
-        ary.length.should eql 4
+        ary = l.to_ary
+        ary.length.should == 4
         0.upto 3 do |i|
-            ary[i].read_string.should eql "D#{i}"
+            ary[i].read_string.should == "D#{i}"
         end
         l.free
     end
@@ -93,9 +87,25 @@ describe Efl::EinaList do
         a << ::FFI::MemoryPointer.from_string("D3")
         l = REinaList.new a
         0.upto 3 do |i|
-            l.nth(i).read_string.should eql "D#{i}"
+            l.nth(i).read_string.should == "D#{i}"
         end
         l.free
     end
     #
+    it "Enumerable should work" 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
+        r = 0
+        l.each do |e| r+=1; end
+        r.should == 4
+        r = l.inject(0) do |s,e| s+=1; s; end
+        r.should == 4
+    end
 end

data/spec/eina_spec.rb

@@ -6,15 +6,15 @@ require 'efl/eina'
 describe Efl::Eina do
     #
     it "should init" do
-        Efl::Eina.init.should eql 1
-        Efl::Eina.init.should eql 2
-        Efl::Eina.init.should eql 3
+        Efl::Eina.init.should == 1
+        Efl::Eina.init.should == 2
+        Efl::Eina.init.should == 3
     end
     #
     it "should shutdown" do
-        Efl::Eina.shutdown.should eql 2
-        Efl::Eina.shutdown.should eql 1
-        Efl::Eina.shutdown.should eql 0
+        Efl::Eina.shutdown.should == 2
+        Efl::Eina.shutdown.should == 1
+        Efl::Eina.shutdown.should == 0
     end
     #
 end