cauterize 0.0.1.pre1 → 0.0.1.pre5

data/spec/enumeration_spec.rb

@@ -1,26 +1,24 @@
-describe Cauterize do
-  before { reset_for_test }
-
-  describe EnumerationValue do
+module Cauterize
+  describe Cauterize::EnumerationValue do
     describe :initialize do
       it "creates an EnumerationValue" do
-        e = EnumerationValue.new(:foo, 1)
+        e = Cauterize::EnumerationValue.new(:foo, 1)
         e.name.should == :foo
         e.value.should == 1
       end
     end
   end
 
-  describe Enumeration do
+  describe Cauterize::Enumeration do
     describe :initialize do
       it "creates a new enumeration with the right name" do
-        Enumeration.new(:foo).name.should == :foo
+        Cauterize::Enumeration.new(:foo).name.should == :foo
       end
     end
 
     describe :value do
       it "adds a new value to the enumeration" do
-        enum = enumeration(:foo) do |e|
+        enum = Cauterize.enumeration(:foo) do |e|
           e.value :a
           e.value :b
           e.value :c
@@ -34,7 +32,7 @@ describe Cauterize do
       end
 
       it "accepts a fixed value" do
-        enum = enumeration(:foo) do |e|
+        enum = Cauterize.enumeration(:foo) do |e|
           e.value :a, 10
           e.value :b, 20
           e.value :c
@@ -47,7 +45,7 @@ describe Cauterize do
 
       it "allows out-of-order values" do
         lambda {
-          enumeration(:foo) do |e|
+          Cauterize.enumeration(:foo) do |e|
             e.value :a, 10
             e.value :b, 9
           end
@@ -56,7 +54,7 @@ describe Cauterize do
 
       it "doesn't allow duplicate ids" do
         lambda {
-          enumeration(:foo) do |e|
+          Cauterize.enumeration(:foo) do |e|
             e.value :a, 1
             e.value :b, 1
           end
@@ -64,7 +62,7 @@ describe Cauterize do
       end
 
       it "doesn't allow accidentally identical ids" do
-        en = enumeration(:foo) do |e|
+        en = Cauterize.enumeration(:foo) do |e|
           e.value :a, 10
           e.value :b, 9
           e.value :c
@@ -75,30 +73,71 @@ describe Cauterize do
 
       it "errors on duplicate names" do
         lambda {
-          enumeration(:foo) do |e|
+          Cauterize.enumeration(:foo) do |e|
             e.value :a
             e.value :a
           end
         }.should raise_error /duplicate name/
       end
     end
+
+    describe :representation do
+      it "chooses int8 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -128
+        end.representation.name.should == :int8
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 127
+        end.representation.name.should == :int8
+      end
+
+      it "chooses int16 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -32768
+        end.representation.name.should == :int16
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 32767
+        end.representation.name.should == :int16
+        Cauterize.enumeration(:c) do |t|
+          t.value :a, 300
+        end.representation.name.should == :int16
+      end
+
+      it "chooses int32 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -2147483648
+        end.representation.name.should == :int32
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 2147483647
+        end.representation.name.should == :int32
+      end
+
+      it "chooses int64 when appropriate" do
+        Cauterize.enumeration(:a) do |t|
+          t.value :a, -9223372036854775808
+        end.representation.name.should == :int64
+        Cauterize.enumeration(:b) do |t|
+          t.value :a, 9223372036854775807
+        end.representation.name.should == :int64
+      end
+    end
   end
 
   describe :enumeration do
     it { creates_a_named_object(:enumeration, Enumeration) }
     it { retrieves_obj_with_identical_name(:enumeration) }
     it { yields_the_object(:enumeration) }
-    it { adds_object_to_hash(:enumeration, :enumerations) }
+    it { adds_object_to_hash(:enumeration, Cauterize.enumerations) }
   end
 
   describe :enumeration! do
     it { creates_a_named_object(:enumeration!, Enumeration) }
     it { raises_exception_with_identical_name(:enumeration!) }
     it { yields_the_object(:enumeration!) }
-    it { adds_object_to_hash(:enumeration!, :enumerations) }
+    it { adds_object_to_hash(:enumeration!, Cauterize.enumerations) }
   end
 
   describe :enumerations do
-    it { is_hash_of_created_objs(:enumeration, :enumerations) }
+    it { is_hash_of_created_objs(:enumeration, Cauterize.enumerations) }
   end
 end

data/spec/fixed_array_spec.rb

@@ -1,22 +1,20 @@
-describe Cauterize do
-  before { reset_for_test }
-
+module Cauterize
   describe :fixed_array  do
     it { creates_a_named_object(:fixed_array, FixedArray) }
     it { retrieves_obj_with_identical_name(:fixed_array) }
     it { yields_the_object(:fixed_array) }
-    it { adds_object_to_hash(:fixed_array, :fixed_arrays) }
+    it { adds_object_to_hash(:fixed_array, Cauterize.fixed_arrays) }
   end
 
   describe :fixed_array! do
     it { creates_a_named_object(:fixed_array!, FixedArray) }
     it { raises_exception_with_identical_name(:variable_array!) }
     it { yields_the_object(:fixed_array!) }
-    it { adds_object_to_hash(:fixed_array!, :fixed_arrays) }
+    it { adds_object_to_hash(:fixed_array!, Cauterize.fixed_arrays) }
   end
 
   describe FixedArray do
-    before { @a = fixed_array(:foo) }
+    before { @a = Cauterize.fixed_array(:foo) }
 
     describe :initialize do
       it "Creates a fixed array." do
@@ -27,21 +25,21 @@ describe Cauterize do
 
     describe :array_type do
       it "Defines the type of the FixedArray." do
-        scalar(:uint32_t)
+        Cauterize.scalar(:uint32_t)
         @a.array_type :uint32_t
         @a.instance_variable_get(:@array_type).name.should == :uint32_t
       end
 
       it "raises an error if type doesn't exist" do
         lambda {
-          fixed_array(:fa) do |f|
+          Cauterize.fixed_array(:fa) do |f|
             f.array_type :lol
           end
         }.should raise_error /lol does not correspond/
       end
 
       it "is the defined type if no argument is passed" do
-        s = scalar(:uint32_t)
+        s = Cauterize.scalar(:uint32_t)
         @a.array_type :uint32_t
         @a.array_type.should be s
       end

data/spec/group_spec.rb

@@ -1,103 +1,108 @@
-describe Cauterize do
-  before { reset_for_test }
-
-  describe :group do
-    it { creates_a_named_object(:group, Group) }
-    it { retrieves_obj_with_identical_name(:group) }
-    it { yields_the_object(:group) }
-    it { adds_object_to_hash(:group, :groups) }
-  end
-
-  describe :group! do
-    it { creates_a_named_object(:group!, Group) }
-    it { raises_exception_with_identical_name(:group!) }
-    it { yields_the_object(:group!) }
-    it { adds_object_to_hash(:group!, :groups) }
-  end
-
-  describe :groups do
-    it "is all the defined groups" do
-      group(:a)
-      group(:b)
-      groups.values.map(&:name).should == [:a, :b]
+module Cauterize
+  describe Cauterize do
+    describe :group do
+      it { creates_a_named_object(:group, Group) }
+      it { retrieves_obj_with_identical_name(:group) }
+      it { yields_the_object(:group) }
+      it { adds_object_to_hash(:group, Cauterize.groups) }
     end
-  end
 
-  describe GroupField do
-    describe :initialize do
-      it "creats a GroupField" do
-        t = scalar(:type)
-        f = GroupField.new(:name, :type)
-        f.name.should == :name
-        f.type.should be t
-      end
+    describe :group! do
+      it { creates_a_named_object(:group!, Group) }
+      it { raises_exception_with_identical_name(:group!) }
+      it { yields_the_object(:group!) }
+      it { adds_object_to_hash(:group!, Cauterize.groups) }
     end
-  end
 
-  describe Group do
-    describe :initialize do
-      it "makes a new Group" do
-        Group.new(:foo).name == :foo
-      end
+    describe :groups do
+      it { is_hash_of_created_objs(:group, Cauterize.groups) }
+    end
 
-      it "creates the tag enum" do
-        e = Group.new(:foo).tag_enum
-        e.name.should == :group_foo_type
-        e.values == {}
+    describe GroupField do
+      describe :initialize do
+        it "creats a GroupField" do
+          t = Cauterize.scalar(:type)
+          f = GroupField.new(:name, :type)
+          f.name.should == :name
+          f.type.should be t
+        end
       end
     end
 
-    describe :field do
-      it "adds a field to the Group" do
-        a = scalar(:aaa)
-        b = scalar(:bbb)
-        grp = group(:foo) do |g|
-          g.field(:a, :aaa)
-          g.field(:b, :bbb)
+    describe Group do
+      describe :initialize do
+        it "makes a new Group" do
+          Group.new(:foo).name == :foo
         end
 
-        grp.fields.values.map(&:name).should == [:a, :b]
+        it "creates the tag enum" do
+          e = Group.new(:foo).tag_enum
+          e.name.should == :group_foo_type
+          e.values == {}
+        end
       end
 
-      it "errors on duplicate field names" do
-        a = scalar(:aaa)
-        lambda {
-          grp = group(:foo) do |g|
-            g.field(:a, :aaa)
+      describe :field do
+        it "adds a field to the Group" do
+          a = Cauterize.scalar(:aaa)
+          b = Cauterize.scalar(:bbb)
+          grp = Cauterize.group(:foo) do |g|
             g.field(:a, :aaa)
+            g.field(:b, :bbb)
           end
-        }.should raise_error /Field name a already used/
-      end
 
-      it "errors on non-existant types" do
-        lambda {
-          grp = group(:foo) do |g|
+          grp.fields.values.map(&:name).should == [:a, :b]
+        end
+
+        it "errors on duplicate field names" do
+          a = Cauterize.scalar(:aaa)
+          lambda {
+            grp = Cauterize.group(:foo) do |g|
+              g.field(:a, :aaa)
+              g.field(:a, :aaa)
+            end
+          }.should raise_error /Field name a already used/
+        end
+
+        it "errors on non-existant types" do
+          lambda {
+            grp = Cauterize.group(:foo) do |g|
+              g.field(:a, :aaa)
+            end
+          }.should raise_error /name aaa does not correspond to a type/
+        end
+
+        it "adds a new value to the enum for each field" do
+          a = Cauterize.scalar(:aaa)
+          b = Cauterize.scalar(:bbb)
+          grp = Cauterize.group(:foo) do |g|
             g.field(:a, :aaa)
+            g.field(:b, :bbb)
           end
-        }.should raise_error /name aaa does not correspond to a type/
-      end
 
-      it "adds a new value to the enum for each field" do
-        a = scalar(:aaa)
-        b = scalar(:bbb)
-        grp = group(:foo) do |g|
-          g.field(:a, :aaa)
-          g.field(:b, :bbb)
+          grp.tag_enum.values.keys.should =~ [:GROUP_FOO_TYPE_A, :GROUP_FOO_TYPE_B]
         end
 
-        grp.tag_enum.values.keys.should =~ [:GROUP_FOO_TYPE_A, :GROUP_FOO_TYPE_B]
+        it "allows nil types" do
+          grp = Cauterize.group(:empty) do |g|
+            g.field(:a)
+            g.field(:b)
+          end
+
+          grp.tag_enum.values.keys.should =~ [:GROUP_EMPTY_TYPE_A, :GROUP_EMPTY_TYPE_B]
+        end
       end
-    end
 
-    describe ".tag_enum" do
-      it "is the enumeration used for the type tag" do
-        Group.new(:foo).tag_enum.class.should be Cauterize::Enumeration
+      describe ".tag_enum" do
+        it "is the enumeration used for the type tag" do
+          Group.new(:foo).tag_enum.class.should be Cauterize::Enumeration
+        end
       end
-    end
 
-    describe "enum_sym" do
-      it "returns the enumeration symbol for a field name" do
-        group(:foo).enum_sym(:a_field).should == :GROUP_FOO_TYPE_A_FIELD
+      describe "enum_sym" do
+        it "returns the enumeration symbol for a field name" do
+          Cauterize.group(:foo).enum_sym(:a_field).should == :GROUP_FOO_TYPE_A_FIELD
+        end
       end
     end
   end

data/spec/scalar_spec.rb

@@ -1,36 +1,46 @@
-describe Cauterize do
-  before do
-    reset_for_test
-    flush_scalars
-  end
-
+module Cauterize
   describe Scalar do
     describe :initialize do
       it "creates an scalar" do
-        scalar(:foo).name.should == :foo
+        Cauterize.scalar(:foo).name.should == :foo
       end
     end
 
     describe :id do
       it { has_a_unique_id_for_each_instance(Scalar) }
     end
+
+    describe :type_name do
+      it "specifies the builtin type to alias" do
+        s = Cauterize.scalar(:foo) do |t|
+          t.type_name(:int8)
+        end
+      end
+
+      it "raises an exception when a non-builtin is specified" do
+        dummy = Cauterize.scalar(:dummy)
+        s = Cauterize.scalar(:foo) do |t|
+          t.type_name(:int32)
+        end
+      end
+    end
   end
 
   describe :scalar do
     it { creates_a_named_object(:scalar, Scalar) }
     it { retrieves_obj_with_identical_name(:scalar) }
     it { yields_the_object(:scalar) }
-    it { adds_object_to_hash(:scalar, :scalars) }
+    it { adds_object_to_hash(:scalar, Cauterize.scalars) }
   end
 
   describe :scalar! do
     it { creates_a_named_object(:scalar!, Scalar) }
     it { raises_exception_with_identical_name(:scalar!) }
     it { yields_the_object(:scalar!) }
-    it { adds_object_to_hash(:scalar!, :scalars) }
+    it { adds_object_to_hash(:scalar!, Cauterize.scalars) }
   end
 
   describe :scalars do
-    it { is_hash_of_created_objs(:scalar, :scalars) }
+    it { is_hash_of_created_objs(:scalar, Cauterize.scalars) }
   end
 end

data/spec/spec_helper.rb

@@ -16,100 +16,109 @@ end
 
 ###
 
-def reset_for_test
-  BaseType.class_variable_set(:@@next_id, {})
-  BaseType.class_variable_set(:@@instances, {})
-  BaseType.class_variable_set(:@@used_names, Set.new)
-
-  Cauterize.module_exec do
-    @enumerations = {}
-    @groups = {}
+module Cauterize
+  module CauterizeHelpers
+    def reset_for_test
+      BaseType.class_variable_set(:@@next_id, {})
+      BaseType.class_variable_set(:@@instances, {})
+
+      Cauterize.module_exec do
+        @builtins = {}
+        @scalars = {}
+        @composites = {}
+        @enumerations = {}
+        @fixed_ararys = {}
+        @variable_arrays = {}
+        @groups = {}
+      end
+
+      Cauterize.create_builtins
+    end
+
+    def is_tagged_as(cls, tag)
+      cls.new(:foo).tag.should == tag
+    end
+
+    def has_a_unique_id_for_each_instance(cls)
+      cls.new(:foo).id.should == 0
+      cls.new(:bar).id.should == 1
+      cls.new(:baz).id.should == 2
+    end
+
+    def creates_a_named_object(fn_sym, obj)
+      fn = Cauterize.method(fn_sym)
+      a = fn.call(:foo)
+      a.class.should == obj
+      a.name.should == :foo
+    end
+
+    def retrieves_obj_with_identical_name(fn_sym)
+      fn = Cauterize.method(fn_sym)
+      a = fn.call(:foo)
+      b = fn.call(:foo)
+      a.should be b
+    end
+
+    def raises_exception_with_identical_name(fn_sym)
+      fn = Cauterize.method(fn_sym)
+      fn.call(:foo)
+      lambda { fn.call(:foo) }.should raise_error
+    end
+
+    def yields_the_object(fn_sym)
+      fn = Cauterize.method(fn_sym)
+      called = false
+      yielded = nil
+      r = fn.call(:foo) { |a| yielded = a }
+      yielded.should be r
+    end
+
+    def adds_object_to_hash(fn_sym, hash_inst)
+      fn = Cauterize.method(fn_sym)
+
+      f = fn.call(:foo)
+      b = fn.call(:bar)
+
+      hash_inst.keys.should == [:foo, :bar]
+      hash_inst.values[0].should be f
+      hash_inst.values[1].should be b
+    end
+
+    def is_hash_of_created_objs(create_fn_sym, hash_inst)
+      create_fn = Cauterize.method(create_fn_sym)
+
+      f = create_fn.call(:foo)
+      b = create_fn.call(:bar)
+      z = create_fn.call(:zap)
+
+      vs = hash_inst.values
+      vs[0].should be f
+      vs[1].should be b
+      vs[2].should be z
+      hash_inst.keys.should == [:foo, :bar, :zap]
+    end
+
+
+    ###############################################################################
+
+    def gen_test_main(sym_list)
+      sym_voids = sym_list.map {|s| "(void*)#{s}"}.join(", ")
+      str = <<-EOF
+      #include "testing.h"
+
+      int main(int argc, char * argv[])
+      {
+        (void)argc;
+        (void)argv;
+
+        void * ptr[] = {#{sym_voids}};
+        (void)ptr;
+
+        return 0;
+      }
+      EOF
+    end
   end
-
-end
-
-def is_tagged_as(cls, tag)
-  cls.new(:foo).tag.should == tag
-end
-
-def has_a_unique_id_for_each_instance(cls)
-  cls.new(:foo).id.should == 0
-  cls.new(:bar).id.should == 1
-  cls.new(:baz).id.should == 2
-end
-
-def creates_a_named_object(fn_sym, obj)
-  fn = method(fn_sym)
-  a = fn.call(:foo)
-  a.class.should == obj
-  a.name.should == :foo
 end
 
-def retrieves_obj_with_identical_name(fn_sym)
-  fn = method(fn_sym)
-  a = fn.call(:foo)
-  b = fn.call(:foo)
-  a.should be b
-end
-
-def raises_exception_with_identical_name(fn_sym)
-  fn = method(fn_sym)
-  fn.call(:foo)
-  lambda { fn.call(:foo) }.should raise_error
-end
-
-def yields_the_object(fn_sym)
-  fn = method(fn_sym)
-  called = false
-  yielded = nil
-  r = fn.call(:foo) { |a| yielded = a }
-  yielded.should be r
-end
-
-def adds_object_to_hash(fn_sym, hash_fn_sym)
-  fn = method(fn_sym)
-  hash_fn = method(hash_fn_sym)
-
-  f = fn.call(:foo)
-  b = fn.call(:bar)
-
-  hash_fn.call.keys.should == [:foo, :bar]
-  hash_fn.call.values[0].should be f
-  hash_fn.call.values[1].should be b
-end
-
-def is_hash_of_created_objs(create_fn_sym, hash_fn_sym)
-  create_fn = method(create_fn_sym)
-  hash_fn = method(hash_fn_sym)
-
-  f = create_fn.call(:foo)
-  b = create_fn.call(:bar)
-  z = create_fn.call(:zap)
-
-  vs = hash_fn.call.values
-  vs[0].should be f
-  vs[1].should be b
-  vs[2].should be z
-  hash_fn.call.keys.should == [:foo, :bar, :zap]
-end
-
-
-###############################################################################
-
-def gen_test_main(sym_list)
-  sym_voids = sym_list.map {|s| "(void*)#{s}"}.join(", ")
-  str = <<-EOF
-  #include "testing.h"
-
-  int main(int argc, char * argv[])
-  {
-    (void)argc;
-    (void)argv;
-
-    void * ptr[] = {#{sym_voids}};
-    (void)ptr;
-
-    return 0;
-  }
-  EOF
-end
+include Cauterize::CauterizeHelpers