ffi-efl 0.0.6 → 0.0.7

data/spec/ecore_getopt_spec.rb

@@ -4,6 +4,7 @@
 require 'efl/ecore'
 require 'efl/ecore_evas'
 require 'efl/eina_list'
+require 'efl/eina_rectangle'
 require 'efl/ecore_getopt'
 #
 describe Efl::EcoreGetopt do
@@ -13,247 +14,233 @@ describe Efl::EcoreGetopt do
     end
     before(:all) do
         Efl::Ecore.init
+    end
+    #
+    before(:each) do
         #
         @p = Efl::EcoreGetopt::REcoreGetopt.new :prog =>"Prog", :usage => "Usage", :version => "0.0.0", :copyright => "less", :license => "MIT", :description => "description", :strict => 1
-        @callback = Proc.new do |parser, desc, string, data, value|
+        #
+        @callback = Proc.new do |parser, desc, string, data, storage|
             parser.address.should == @p.to_ptr.address
-            string.should == "my_data"
+            Efl::Native::EcoreGetoptDesc.new(desc)[:shortname].chr.should == 'b'
+            string.should == "user_arg"
             data.read_string.should == "cb_data"
-            value.read_pointer.read_int.should == 99
+            storage.read_pointer.read_int.should == 69
+            storage.read_pointer.write_int 666
             true
         end
+        @g = Efl::Native::EinaRectangleStruct.new
+        @g[:x] = 100; @g[:y] = 200; @g[:w] = 300; @g[:h] = 400
         #
-        @values = {
-            :license => FFI::MemoryPointer.new(:uchar),
-            :copyright => FFI::MemoryPointer.new(:uchar),
-            :version => FFI::MemoryPointer.new(:uchar),
-            :help => FFI::MemoryPointer.new(:uchar),
-            :engines => FFI::MemoryPointer.new(:uchar),
-            :int => FFI::MemoryPointer.new(:int),
-            :double => FFI::MemoryPointer.new(:double),
-            :short => FFI::MemoryPointer.new(:short),
-            :long => FFI::MemoryPointer.new(:long),
-            :const => FFI::MemoryPointer.new(:int),
-            :true => FFI::MemoryPointer.new(:uchar),
-            :false => FFI::MemoryPointer.new(:uchar),
-            :choice => FFI::MemoryPointer.new(:pointer),
-            :append => FFI::MemoryPointer.new(:pointer),
-            :count => FFI::MemoryPointer.new(:int),
-            :callback => FFI::MemoryPointer.new(:int),
-        }
-        @meta1 = FFI::MemoryPointer.from_string "My pretty"
-        @meta2 = FFI::MemoryPointer.from_string "My precious"
-        @cb_data = FFI::MemoryPointer.from_string "cb_data"
-        #
-        @p.license 'L', 'license'
-        @p.value :boolp, @values[:license]
-        @p.copyright 'C', 'copyright'
-        @p.value :boolp, @values[:copyright]
+        # license and copyright share the same flag named quit
+        @p.license 'L', 'license', 'quit'
+        @p.copyright 'C', 'copyright', 'quit'
         @p.version 'V', 'version'
-        @p.value :boolp, @values[:version]
         @p.help 'H', 'help'
-        @p.value :boolp, @values[:help]
-        # FIXME debug callback : ecore_getopt_callback_ecore_evas_list_engines
-#        @p.callback_noargs 'E', 'list-engines', 'list ecore-evas available engines', @engines_cb, FFI::Pointer::NULL
-        @p.callback_noargs 'E', 'list-engines', 'list ecore-evas available engines', Efl::Native.method(:ecore_getopt_callback_ecore_evas_list_engines), FFI::Pointer::NULL
-        @p.value :boolp, @values[:engines]
-        @p.store_type :int, 'i', 'int', 'store an integer'
-        @p.value :intp, @values[:int]
-        @p.store_meta_type :double, 'd', 'double', 'store an double+meta', @meta1
-        @p.value :doublep, @values[:double]
-        @p.store_def_type :short, 's', 'short', 'store an short+default', 6
-        @p.value :shortp, @values[:short]
-        @p.store_full_type :long, 'l', 'long', 'store a long+full', @meta2, :ecore_getopt_desc_arg_requirement_yes, 666
-        @p.value :longp, @values[:long]
-        @p.store_const 'c', 'const', 'store a constant', 123456
-        @p.value :intp, @values[:const]
+        @p.store 'i', 'int', 'store an integer', :int, 2
+        @p.store_meta 'd', 'double', 'store an double+meta', "My pretty meta", :double, 3.1415926
+        @p.store_def 's', 'string', 'store an string+default', :string, "default"
+        @p.store_full 'l', 'long', 'store a long+full', "My precious meta", :ecore_getopt_desc_arg_requirement_yes, :long, 666
+        @p.store_const 'c', 'const', 'store a constant', -666, 123456
         @p.store_true 't', 'true', 'store true'
-        @p.value :boolp, @values[:false]
         @p.store_false 'f', 'false', 'store false'
-        @p.value :boolp, @values[:true]
+        @p.count 'k', 'count', 'store count', 664
+        @p.append 'a', 'append', 'store append', :int, [1,2,3]
         @p.choice 'm', 'many', 'store choice', ['ch1','ch2','ch3']
-        @p.value :strp, @values[:choice]
-        @p.append 'a', 'append', 'store append', :ecore_getopt_type_int
-        @p.value :listp, @values[:append]
-        @p.count 'k', 'count', 'store count'
-        @p.value :intp, @values[:count]
-        @p.callback_args 'b', 'callback', 'callback full', @meta1, @callback, @cb_data
-        @p.value :intp, @values[:callback]
+        @p.callback_args 'b', 'callback', 'callback full', "Another meta", @callback, "cb_data", :int, 69
+        @p.callback_noargs 'E', 'list-engines', 'list ecore-evas available engines',
+            Efl::Native.method(:ecore_getopt_callback_ecore_evas_list_engines)
+        @p.callback_args 'g', 'geometry', 'x:y:w:h', "X:Y:W:H",
+            Efl::Native.method(:ecore_getopt_callback_geometry_parse), nil, :pointer, @g
         @p.create
-#        puts @p.debug
         #
     end
-    before(:each) do
-        [ :license, :copyright, :version, :help, :engines ].each do |sym|
-            @values[sym].write_char 0
-        end
-        @values[:int].write_int 0
-        @values[:double].write_double 3.1415926
-        @values[:short].write_short 9
-        @values[:long].write_long 666
-        @values[:const].write_int -666
-        @values[:true].write_uchar 1
-        @values[:false].write_uchar 0
-        @values[:choice].write_pointer FFI::Pointer::NULL
-        @values[:append].write_pointer FFI::Pointer::NULL
-        @values[:count].write_int 664
-        @values[:callback].write_int 99
-    end
     #
     describe "license copyright version help" do
+        if ENV['DEBUG']
+            it "DEBUG" do
+                puts @p.debug
+            end
+        end
         it "should handle -L" do
             args = @p.parse ["My lovely prog name","-L"]
-            @values[:license].read_char.should == 1
+            @p['quit'].should == 1
         end
         it "should handle --license" do
             args = @p.parse ["My lovely prog name","--license"]
-            @values[:license].read_char.should == 1
+            @p['quit'].should == 1
         end
         it "should handle -C" do
             args = @p.parse ["progname","-C"]
-            @values[:copyright].read_char.should == 1
+            @p['quit'].should == 1
         end
         it "should handle --copyright" do
             args = @p.parse ["My lovely prog name","--copyright"]
-            @values[:copyright].read_char.should == 1
+            @p['quit'].should == 1
         end
         it "should handle -V" do
             args = @p.parse ["My lovely prog name","-V"]
-            @values[:version].read_char.should == 1
+            @p['V'].should == 1
         end
         it "should handle --version" do
             args = @p.parse ["progname","--version"]
-            @values[:version].read_char.should == 1
+            @p['V'].should == 1
         end
         it "should handle -H" do
             args = @p.parse ["My lovely prog name","-H"]
-            @values[:help].read_char.should == 1
+            @p['H'].should == 1
         end
         it "should handle --help" do
             args = @p.parse ["progname","--help"]
-            @values[:help].read_char.should == 1
-        end
-        it "should handle -E" do
-            args = @p.parse ["My lovely prog name","-E"]
-            @values[:engines].read_char.should == 1
-        end
-        it "should handle --list-engines" do
-            args = @p.parse ["My lovely prog name","--list-engines"]
-            @values[:engines].read_char.should == 1
+            @p['H'].should == 1
         end
     end
     describe "simple short options" do
         it "should handle -i" do
-            @values[:int].read_int.should == 0
+            @p['i'].should == 2
             args = @p.parse ["progname","-i 666"]
-            @values[:int].read_int.should == 666
+            @p['i'].should == 666
         end
         it "should handle -d" do
-            @values[:double].read_double.should == 3.1415926
+            @p['d'].should == 3.1415926
             args = @p.parse ["progname","-d 6.66"]
-            @values[:double].read_double.should == 6.66
+            @p['d'].should == 6.66
         end
         it "should handle -s" do
-            @values[:short].read_short.should == 9
-            args = @p.parse ["progname","-s 125"]
-            @values[:short].read_short.should == 125
+            @p['s'].should == 'default'
+            args = @p.parse ["progname","-sset"]
+            @p['s'].should == 'set'
         end
         it "should handle -l" do
-            @values[:long].read_long.should == 666
+            @p['l'].should == 666
             args = @p.parse ["progname","-l 69"]
-            @values[:long].read_long.should == 69
+            @p['l'].should == 69
         end
         it "should handle -c" do
-            @values[:const].read_int.should == -666
+            @p['c'].should == -666
             args = @p.parse ["progname","-c"]
-            @values[:const].read_int.should == 123456
+            @p['c'].should == 123456
         end
         it "should handle -t" do
-            @values[:false].read_uchar.should == 0
+            @p['t'].should == 0
             args = @p.parse ["progname","-t"]
-            @values[:false].read_uchar.should == 1
+            @p['t'].should == 1
         end
         it "should handle -f" do
-            @values[:true].read_uchar.should == 1
+            @p['f'].should == 1
             args = @p.parse ["progname","-f"]
-            @values[:true].read_uchar.should == 0
+            @p['f'].should == 0
         end
-        it "should handle -m" do
-            @values[:choice].read_pointer.should == FFI::Pointer::NULL
-            args = @p.parse ["progname","-mch2"]
-            @values[:choice].read_pointer.read_string.should == "ch2"
+        it "should handle -k" do
+            @p['k'].should == 664
+            args = @p.parse ["progname","-kk"]
+            @p['k'].should == 666
         end
         it "should handle -a" do
-            @values[:append].read_pointer.should == FFI::Pointer::NULL
+            @p['a'].should == [1,2,3]
             args = @p.parse ["progname","-a10", "-a20"]
-            l = Efl::EinaList::REinaList.new(@values[:append].read_pointer).to_a
-            l[0].read_int.should==10
-            l[1].read_int.should==20
+            @p['a'].should == [1,2,3,10,20]
         end
-        it "should handle -k" do
-            @values[:count].read_int.should == 664
-            args = @p.parse ["progname","-kk"]
-            @values[:count].read_int.should == 666
+        it "should handle -m" do
+            @p['m'].should == nil
+            args = @p.parse ["progname","-mch2"]
+            @p['m'].should == "ch2"
         end
         it "should handle -b" do
-            args = @p.parse ["progname","-bmy_data"]
+            @p['b'].should == 69
+            args = @p.parse ["progname","-buser_arg"]
+            @p['b'].should == 666
+        end
+        it "should handle -E" do
+            args = @p.parse ["My lovely prog name","-E"]
+            @p['E'].should == 1
+        end
+        it "should handle -g" do
+            g = Efl::Native::EinaRectangleStruct.new @p['g']
+            g[:x].should == 100
+            g[:y].should == 200
+            g[:w].should == 300
+            g[:h].should == 400
+            args = @p.parse ["progname","-g=10:20:30:40"]
+            g = Efl::Native::EinaRectangleStruct.new @p['g']
+            g[:x].should == 10
+            g[:y].should == 20
+            g[:w].should == 30
+            g[:h].should == 40
         end
     end
     describe "simple long options" do
         it "should handle --int" do
-            @values[:int].read_int.should == 0
+            @p['i'].should == 2
             args = @p.parse ["progname","--int=666"]
-            @values[:int].read_int.should == 666
+            @p['i'].should == 666
         end
         it "should handle --double" do
-            @values[:double].read_double.should == 3.1415926
+            @p['d'].should == 3.1415926
             args = @p.parse ["progname","--double=6.66"]
-            @values[:double].read_double.should == 6.66
+            @p['d'].should == 6.66
         end
-        it "should handle --short" do
-            @values[:short].read_short.should == 9
-            args = @p.parse ["progname","--short=125"]
-            @values[:short].read_short.should == 125
+        it "should handle --string" do
+            @p['s'].should == 'default'
+            args = @p.parse ["progname","--string=set"]
+            @p['s'].should == 'set'
         end
         it "should handle --long" do
-            @values[:long].read_long.should == 666
+            @p['l'].should == 666
             args = @p.parse ["progname","--long=69"]
-            @values[:long].read_long.should == 69
+            @p['l'].should == 69
         end
         it "should handle --const" do
-            @values[:const].read_int.should == -666
+            @p['c'].should == -666
             args = @p.parse ["progname","--const"]
-            @values[:const].read_int.should == 123456
+            @p['c'].should == 123456
         end
         it "should handle --true" do
-            @values[:false].read_uchar.should == 0
+            @p['t'].should == 0
             args = @p.parse ["progname","--true"]
-            @values[:false].read_uchar.should == 1
+            @p['t'].should == 1
         end
         it "should handle --false" do
-            @values[:true].read_uchar.should == 1
+            @p['f'].should == 1
             args = @p.parse ["progname","--false"]
-            @values[:true].read_uchar.should == 0
+            @p['f'].should == 0
         end
-        it "should handle --many" do
-            @values[:choice].read_pointer.should == FFI::Pointer::NULL
-            args = @p.parse ["progname","--many=ch3"]
-            @values[:choice].read_pointer.read_string.should == "ch3"
+        it "should handle --count" do
+            @p['k'].should == 664
+            args = @p.parse ["progname","--count","--count"]
+            @p['k'].should == 666
         end
-        it "should handle -append" do
-            @values[:append].read_pointer.should == FFI::Pointer::NULL
+        it "should handle --append" do
+            @p['a'].should == [1,2,3]
             args = @p.parse ["progname","--append=10", "--append=20"]
-            l = Efl::EinaList::REinaList.new(@values[:append].read_pointer).to_a
-            l[0].read_int.should==10
-            l[1].read_int.should==20
+            @p['a'].should == [1,2,3,10,20]
         end
-        it "should handle --count" do
-            @values[:count].read_int.should == 664
-            args = @p.parse ["progname","--count","--count"]
-            @values[:count].read_int.should == 666
+        it "should handle --many" do
+            @p['m'].should == nil
+            args = @p.parse ["progname","--many=ch3"]
+            @p['m'].should == "ch3"
         end
         it "should handle --callback" do
-            args = @p.parse ["progname","--callback=my_data"]
+            @p['b'].should == 69
+            args = @p.parse ["progname","--callback=user_arg"]
+            @p['b'].should == 666
+        end
+        it "should handle --list-engines" do
+            args = @p.parse ["My lovely prog name","--list-engines"]
+            @p['E'].should == 1
+        end
+        it "should handle --geometry" do
+            g = Efl::Native::EinaRectangleStruct.new @p['g']
+            g[:x].should == 100
+            g[:y].should == 200
+            g[:w].should == 300
+            g[:h].should == 400
+            args = @p.parse ["progname","--geometry=10:20:30:40"]
+            g = Efl::Native::EinaRectangleStruct.new @p['g']
+            g[:x].should == 10
+            g[:y].should == 20
+            g[:w].should == 30
+            g[:h].should == 40
         end
     end
 end

data/spec/ecore_input_spec.rb

@@ -7,18 +7,22 @@ describe Efl::EcoreInput do
     #
     before(:all) do
         EcoreInput = Efl::EcoreInput
+        @init = EcoreInput.init
+    end
+    after(:all) do
+        EcoreInput.shutdown
     end
     #
     it "should init" do
-        EcoreInput.init.should == 1
-        EcoreInput.init.should == 2
-        EcoreInput.init.should == 3
+        EcoreInput.init.should == @init+1
+        EcoreInput.init.should == @init+2
+        EcoreInput.init.should == @init+3
     end
     #
     it "should shutdown" do
-        EcoreInput.shutdown.should == 2
-        EcoreInput.shutdown.should == 1
-        EcoreInput.shutdown.should == 0
+        EcoreInput.shutdown.should == @init+2
+        EcoreInput.shutdown.should == @init+1
+        EcoreInput.shutdown.should == @init
     end
     #
 end

data/spec/ecore_spec.rb

@@ -22,22 +22,22 @@ describe "Efl::Ecore #{Efl::Ecore.version.full}" do
         OK = FFI::MemoryPointer.from_string "ok"
         KO = FFI::MemoryPointer.from_string "ko"
         NONE = FFI::MemoryPointer.from_string "none"
+        @init = Ecore.init
+    end
+    after(:all) do
+        Ecore.shutdown
     end
-    before(:each) {
-        Ecore.init==1
-    }
-    after(:each) {
-        Ecore.shutdown==0
-    }
     #
     it "should init" do
-        Ecore.init.should == 2
-        Ecore.init.should == 3
+        Ecore.init.should == @init+1
+        Ecore.init.should == @init+2
+        Ecore.init.should == @init+3
     end
     #
     it "should shutdown" do
-        Ecore.shutdown.should == 2
-        Ecore.shutdown.should == 1
+        Ecore.shutdown.should == @init+2
+        Ecore.shutdown.should == @init+1
+        Ecore.shutdown.should == @init
     end
     #
     it "should run a single iteration of the mainloop" do
@@ -60,6 +60,7 @@ describe "Efl::Ecore #{Efl::Ecore.version.full}" do
         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.event_handler_del(evt_handler).address.should == OK.address
     end
     #
     it "should be able to get and set event handler data" do
@@ -73,6 +74,7 @@ describe "Efl::Ecore #{Efl::Ecore.version.full}" do
         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.event_handler_del(evt_handler).address.should == OK.address
     end
     #
     it "should be able to create new event type" do
@@ -111,17 +113,21 @@ describe "Efl::Ecore #{Efl::Ecore.version.full}" do
             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
+        evt_handler = Ecore.event_handler_add Ecore::EVENT_SIGNAL_USER, USER_SIGNAL_CB, OK
         e1 = FFI::MemoryPointer.new(:int)
         e1.write_int 69
         evt1 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e1, event_free_cb, KO
         e2 = FFI::MemoryPointer.new(:int)
         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 == OK.address
         evt2 = Ecore.event_add Ecore::EVENT_SIGNAL_USER, e2, EVENT_FREE_CB, NONE
-        Ecore.main_loop_begin   # process event
+        Ecore.event_handler_del(evt_handler).address.should == OK.address
+        Ecore.main_loop_iterate
+        Ecore.main_loop_iterate
+        Ecore.main_loop_iterate
+        e1.free
+        e2.free
     end
     #
     describe Efl::Ecore::REcorePipe do

data/spec/edje_spec.rb

@@ -23,22 +23,24 @@ require './spec/helper'
 #
 describe "Efl::Edje #{Efl::Edje.version.full}" do
     #
-    before(:all) {
+    before(:all) do
         Edje = Efl::Edje
-        Edje.init.should == 1
-    }
-    after(:all) {
-        Edje.shutdown == 0
-    }
+        @init = Edje.init
+    end
+    after(:all) do
+        Edje.shutdown
+    end
     #
     it "should init" do
-        Edje.init.should == 2
-        Edje.init.should == 3
+        Edje.init.should == @init+1
+        Edje.init.should == @init+2
+        Edje.init.should == @init+3
     end
     #
     it "should shutdown" do
-        Edje.shutdown.should == 2
-        Edje.shutdown.should == 1
+        Edje.shutdown.should == @init+2
+        Edje.shutdown.should == @init+1
+        Edje.shutdown.should == @init
     end
     #
     it "frametime get/set " do
@@ -105,7 +107,7 @@ describe "Efl::Edje #{Efl::Edje.version.full}" do
         after(:all) do
             @e.free
             @pixels.free
-            Efl::Evas.shutdown.should==0
+            Efl::Evas.shutdown
         end
         #
         it "scale get/set " do

data/spec/eet_spec.rb

@@ -5,24 +5,28 @@ require 'efl/eet'
 #
 describe "Efl::Eet #{Efl::Eet.version.full}" do
     #
-    before(:all) {
+    before(:all) do
         Eet = Efl::Eet
         Native = Efl::Native unless Kernel.const_defined? 'Native'
         REetFile = Efl::Eet::REetFile
-    }
+        @init = Eet.init
+    end
+    after(:all) do
+        Eet.shutdown
+    end
     #
     FP = '/tmp/_eet.cfg'
     #
     it "should init" do
-        Eet.init.should == 1
-        Eet.init.should == 2
-        Eet.init.should == 3
+        Eet.init.should == @init+1
+        Eet.init.should == @init+2
+        Eet.init.should == @init+3
     end
     #
     it "should shutdown" do
-        Eet.shutdown.should == 2
-        Eet.shutdown.should == 1
-        Eet.shutdown.should == 0
+        Eet.shutdown.should == @init+2
+        Eet.shutdown.should == @init+1
+        Eet.shutdown.should == @init
     end
     #
     it "should clearcache" do
@@ -39,8 +43,6 @@ describe "Efl::Eet #{Efl::Eet.version.full}" do
     end
     #
     describe Efl::Eet::REetFile do
-        before(:all) { Eet.init.should==1 }
-        after(:all) { Eet.shutdown.should==0 }
         #
         it "should open and close" do
             f = REetFile.open FP, Native.enum_type(:eet_file_mode)[:eet_file_mode_write]

data/spec/eina_hash_spec.rb

@@ -6,17 +6,17 @@ require 'efl/eina_hash'
 #
 describe Efl::EinaHash do
     #
-    before(:all) {
+    before(:all) do
         REinaHash = Efl::EinaHash::REinaHash
-        Efl::Eina.init.should == 1
+        Efl::Eina.init
         @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 == 0
-    }
+    end
+    after(:all) do
+        Efl::Eina.shutdown
+    end
     #
     it "should append prepend and fetch" do
         h = REinaHash.new