cauterize 0.0.1.pre1 → 0.0.1.pre5

data/spec/builders/c/buildable_spec.rb

@@ -1,24 +1,24 @@
-include Cauterize::Builders::C
+module Cauterize::Builders::C
+  describe Cauterize::Builders::C do
+    describe Buildable do
+      subject { Buildable.new(:some_blueprint) }
 
-describe Cauterize::Builders::C do
-  describe Buildable do
-    subject { Buildable.new(:some_blueprint) }
-
-    describe "required methods" do
-      it "raises errors on required interfaces" do
-        lambda {
-          REQUIRED_METHODS.each do |m|
-            subject.send(m)
-          end
-        }.should raise_error /must implement/
+      describe "required methods" do
+        it "raises errors on required interfaces" do
+          lambda {
+            REQUIRED_METHODS.each do |m|
+              subject.send(m)
+            end
+          }.should raise_error /must implement/
+        end
       end
-    end
 
-    describe :method_missing do
-      it "calls the original if method not required" do
-        lambda {
-          subject.is_not_defined
-        }.should raise_error NoMethodError
+      describe :method_missing do
+        it "calls the original if method not required" do
+          lambda {
+            subject.is_not_defined
+          }.should raise_error NoMethodError
+        end
       end
     end
   end

data/spec/builders/c/builtin_spec.rb

@@ -0,0 +1,22 @@
+module Cauterize
+  describe Builders::C::BuiltIn do
+    let(:bi) do
+      b = BuiltIn.new(:foo)
+      b.is_signed(false)
+      b.byte_length(4)
+      b
+    end
+
+    let (:bi_bldr) do
+      Builders.get(:c, bi)
+    end
+
+    describe ".declare" do
+      it "declares a variable with the BuiltIn's type" do
+        f = default_formatter
+        bi_bldr.declare(f, :meep)
+        f.to_s.should == "uint32_t meep;"
+      end
+    end
+  end
+end

data/spec/builders/c/composite_spec.rb

@@ -1,45 +1,49 @@
-describe Cauterize::Builders::C::Composite do
-  let(:type_constructor) do
-    lambda do |name|
-      scalar(:int32)
-      composite(name) do |c|
-        c.field :an_int, :int32
-        c.field :another_int, :int32
+module Cauterize
+  describe Cauterize::Builders::C::Composite do
+    before do
+      Cauterize.scalar(:my_int) {|t| t.type_name(:int32)}
+    end
+
+    let(:type_constructor) do
+      lambda do |name|
+        Cauterize.composite(name) do |c|
+          c.field :an_int, :my_int
+          c.field :another_int, :my_int
+        end
       end
     end
-  end
 
-  it_behaves_like "a buildable"
-  it_behaves_like "a sane buildable"
-  include_examples "no enum"
+    it_behaves_like "a buildable"
+    it_behaves_like "a sane buildable"
+    include_examples "no enum"
 
-  context "structure definition" do
-    let(:comp) do
-      scalar(:int32)
-      _c = composite(:foo) do |c|
-        c.field(:an_int, :int32)
-      end
+    context "structure definition" do
+      let(:comp) do
+        _c = Cauterize.composite(:foo) do |c|
+          c.field(:an_int, :my_int)
+        end
 
-      Builders.get(:c, _c)
-    end
+        Builders.get(:c, _c)
+      end
 
-    describe ".struct_proto" do
-      it "defines a structure prototype" do
-        f = default_formatter
-        comp.struct_proto(f)
-        f.to_s.should == "struct foo;"
+      describe ".struct_proto" do
+        it "defines a structure prototype" do
+          f = default_formatter
+          comp.struct_proto(f)
+          f.to_s.should == "struct foo;"
+        end
       end
-    end
 
-    describe ".struct_defn" do
-      it "defines a structure definition" do
-        f = default_formatter
-        comp.struct_defn(f)
-        fs = f.to_s
+      describe ".struct_defn" do
+        it "defines a structure definition" do
+          f = default_formatter
+          comp.struct_defn(f)
+          fs = f.to_s
 
-        fs.should match /struct foo/
-        fs.should match /int32 an_int;/
-        fs.should match /};/
+          fs.should match /struct foo/
+          fs.should match /my_int an_int;/
+          fs.should match /};/
+        end
       end
     end
   end

data/spec/builders/c/enumeration_spec.rb

@@ -1,32 +1,95 @@
-describe Cauterize::Builders::C::Enumeration do
-  let(:type_constructor) { lambda {|name| enumeration(name)}}
+module Cauterize
+  describe Cauterize::Builders::C::Enumeration do
+    let(:type_constructor) { lambda {|name|
+      Cauterize.enumeration(name) do |t|
+        t.value :a, 100
+      end
+    }}
+
+    it_behaves_like "a buildable"
+    it_behaves_like "a sane buildable"
+    include_examples "no struct"
 
-  it_behaves_like "a buildable"
-  it_behaves_like "a sane buildable"
-  include_examples "no struct"
+    describe ".enum_defn" do
+      let(:en) do
+        _e = Cauterize.enumeration(:foo) do |e|
+          e.value :aaa
+          e.value :bbb
+          e.value "QuickBrownFox".to_sym
+        end
 
-  describe ".enum_defn" do
-    let(:en) do
-      _e = enumeration(:foo) do |e|
-        e.value :aaa
-        e.value :bbb
-        e.value "QuickBrownFox".to_sym
+        f = default_formatter
+        Builders.get(:c, _e).enum_defn(f)
+        f.to_s
       end
 
-      f = default_formatter
-      Builders.get(:c, _e).enum_defn(f)
-      f.to_s
+      it "contains the enum name" do
+        en.should match /enum foo/
+      end
+
+      it "contains an entry for each value" do
+        en.should match /AAA = 0,/
+        en.should match /BBB = 1,/
+        en.should match /QUICK_BROWN_FOX = 2,/
+        en.should match /};/
+      end
     end
 
-    it "contains the enum name" do
-      en.should match /enum foo/
+    describe ".packer_defn" do
+      let(:en0) do
+        _e = Cauterize.enumeration(:foo) do |e|
+          e.value :aaa
+          e.value :bbb
+          e.value "QuickBrownFox".to_sym
+        end
+
+        f = default_formatter
+        Builders.get(:c, _e).packer_defn(f)
+        f.to_s
+      end
+
+      let(:en1) do
+        _e = Cauterize.enumeration(:bar) do |e|
+          e.value :aaa, 500
+          e.value :bbb, -30
+        end
+
+        f = default_formatter
+        Builders.get(:c, _e).packer_defn(f)
+        f.to_s
+      end
+
+      it "defines a representation variable" do
+        en0.should match /int8_t enum_representation;/
+        en1.should match /int16_t enum_representation;/
+      end
+
+      it "references a packer for the representation" do
+        en0.should match /Pack_int8/
+        en1.should match /Pack_int16/
+      end
     end
 
-    it "contains an entry for each value" do
-      en.should match /AAA = 0,/
-      en.should match /BBB = 1,/
-      en.should match /QUICK_BROWN_FOX = 2,/
-      en.should match /};/
+    describe ".unpacker_defn" do
+      let(:en) do
+        _e = Cauterize.enumeration(:foo) do |e|
+          e.value :aaa
+          e.value :bbb
+          e.value "QuickBrownFox".to_sym
+        end
+
+        f = default_formatter
+        Builders.get(:c, _e).unpacker_defn(f)
+        f.to_s
+      end
+
+      it "defines a representation variable" do
+        en.should match /int8_t enum_representation;/
+      end
+
+      it "references a unpacker for the representation" do
+        en.should match /Unpack_int8/
+      end
     end
   end
 end

data/spec/builders/c/fixed_array_spec.rb

@@ -1,8 +1,8 @@
 describe Cauterize::Builders::C::FixedArray do
   let(:type_constructor) do
-    scalar(:uint32_t)
+    Cauterize.scalar(:uint32_t)
     lambda do |name|
-      fixed_array(name) do |a|
+      Cauterize.fixed_array(name) do |a|
         a.array_type :uint32_t
         a.array_size 16
       end
@@ -10,8 +10,8 @@ describe Cauterize::Builders::C::FixedArray do
   end
 
   it_behaves_like "a buildable"
+  it_behaves_like "a sane buildable"
   include_examples "no enum"
-  include_examples "no struct"
 
   context "an array buildable" do
     let(:desc_instance) { type_constructor.call(:some_type_name) }
@@ -20,8 +20,8 @@ describe Cauterize::Builders::C::FixedArray do
 
     describe :render do
       it "contains the name" do
-        t_name = subject.instance_variable_get(:@blueprint).array_type.name
-        subject.render.should match /#{t_name}/
+        name = subject.instance_variable_get(:@blueprint).name
+        subject.render.should match /#{name}/
       end
     end
 
@@ -29,7 +29,7 @@ describe Cauterize::Builders::C::FixedArray do
       before { subject.declare(formatter, :some_sym) }
 
       it "contains the name and a ;" do
-        formatter.to_s.should match /uint32_t some_sym\[16\]; \/\* some_type_name \*\//
+        formatter.to_s.should match /struct some_type_name some_sym;/
       end
     end
   end

data/spec/builders/c/group_spec.rb

@@ -1,111 +1,118 @@
-describe Cauterize::Builders::C::Group do
-  let(:type_constructor) { lambda {|name| group(name)}}
-
-  it_behaves_like "a buildable"
-  it_behaves_like "a sane buildable"
-  include_examples "no enum"
-
-  context "enumeration for type tag" do
-    before do
-      scalar(:uint8_t)
-      @g = group!(:some_name) do |_g|
-        _g.field(:a, :uint8_t)
-        _g.field(:b, :uint8_t)
-      end
-      @b = Cauterize::Builders::C::Group.new(@g)
-    end
-
-    describe ".initialize" do
-      it "creates the enumeration tag" do
-        @b.instance_variable_get(:@tag_enum).class.name.should == "Cauterize::Enumeration"
-      end
-    end
+module Cauterize
+  describe Cauterize::Builders::C::Group do
+    let(:type_constructor) { lambda {|name| Cauterize.group(name)}}
 
-    describe "@tag_enum" do
-      it "contains a entry for each field in the group" do
-        e = @b.instance_variable_get(:@tag_enum)
-        e.values.keys.should =~ [ :GROUP_SOME_NAME_TYPE_A,
-                                  :GROUP_SOME_NAME_TYPE_B ]
-      end
-    end
+    it_behaves_like "a buildable"
+    it_behaves_like "a sane buildable"
+    include_examples "no enum"
 
-    describe ".packer_defn" do
+    context "enumeration for type tag" do
       before do
-        f = default_formatter
-        @b.packer_defn(f)
-        @fs = f.to_s
-      end
-
-      it "contains the enum packer" do
-        @fs.should match /Pack_group_some_name_type/
-      end
-
-      it "contains each tag" do
-        @fs.should match /GROUP_SOME_NAME_TYPE_A/
-        @fs.should match /GROUP_SOME_NAME_TYPE_B/
+        Cauterize.scalar(:uint8_t)
+        @g = Cauterize.group!(:some_name) do |_g|
+          _g.field(:a, :uint8_t)
+          _g.field(:b, :uint8_t)
+          _g.field(:c)
+        end
+        @b = Cauterize::Builders::C::Group.new(@g)
       end
 
-      it "contains each field" do
-        @fs.should match /src->data\.a/
-        @fs.should match /src->data\.b/
-      end
-    end
-
-    describe ".unpacker_defn" do
-      before do
-        f = default_formatter
-        @b.unpacker_defn(f)
-        @fs = f.to_s
+      describe ".initialize" do
+        it "creates the enumeration tag" do
+          @b.instance_variable_get(:@tag_enum).class.name.should == "Cauterize::Enumeration"
+        end
       end
 
-      it "contains the enum unpacker" do
-        @fs.should match /Unpack_group_some_name_type/
+      describe "@tag_enum" do
+        it "contains a entry for each field in the group" do
+          e = @b.instance_variable_get(:@tag_enum)
+          e.values.keys.should =~ [ :GROUP_SOME_NAME_TYPE_A,
+                                    :GROUP_SOME_NAME_TYPE_B,
+                                    :GROUP_SOME_NAME_TYPE_C ]
+        end
       end
 
-      it "contains each tag" do
-        @fs.should match /GROUP_SOME_NAME_TYPE_A/
-        @fs.should match /GROUP_SOME_NAME_TYPE_B/
+      describe ".packer_defn" do
+        before do
+          f = default_formatter
+          @b.packer_defn(f)
+          @fs = f.to_s
+        end
+
+        it "contains the enum packer" do
+          @fs.should match /Pack_group_some_name_type/
+        end
+
+        it "contains each tag" do
+          @fs.should match /GROUP_SOME_NAME_TYPE_A/
+          @fs.should match /GROUP_SOME_NAME_TYPE_B/
+          @fs.should match /GROUP_SOME_NAME_TYPE_C/
+        end
+
+        it "contains each data field" do
+          @fs.should match /src->data\.a/
+          @fs.should match /src->data\.b/
+        end
       end
 
-      it "contains each field" do
-        @fs.should match /dst->data\.a/
-        @fs.should match /dst->data\.b/
+      describe ".unpacker_defn" do
+        before do
+          f = default_formatter
+          @b.unpacker_defn(f)
+          @fs = f.to_s
+        end
+
+        it "contains the enum unpacker" do
+          @fs.should match /Unpack_group_some_name_type/
+        end
+
+        it "contains each tag" do
+          @fs.should match /GROUP_SOME_NAME_TYPE_A/
+          @fs.should match /GROUP_SOME_NAME_TYPE_B/
+          @fs.should match /GROUP_SOME_NAME_TYPE_C/
+        end
+
+        it "contains each data field" do
+          @fs.should match /dst->data\.a/
+          @fs.should match /dst->data\.b/
+        end
       end
     end
-  end
 
-  context "structure definition" do
-    let(:grp) do
-      scalar(:int32)
-      _g = group(:oof) do |g|
-        g.field(:aaa, :int32)
-        g.field(:bbb, :int32)
-      end
+    context "structure definition" do
+      let(:grp) do
+        _g = Cauterize.group(:oof) do |g|
+          g.field(:aaa, :int32)
+          g.field(:bbb, :int32)
+          g.field(:empty)
+        end
 
-      Builders.get(:c, _g)
-    end
+        Builders.get(:c, _g)
+      end
 
-    describe ".struct_proto" do
-      it "defines a structure prototype" do
-        f = default_formatter
-        grp.struct_proto(f)
-        f.to_s.should == "struct oof;"
+      describe ".struct_proto" do
+        it "defines a structure prototype" do
+          f = default_formatter
+          grp.struct_proto(f)
+          f.to_s.should == "struct oof;"
+        end
       end
-    end
 
-    describe ".struct_defn" do
-      it "defines a structure definition" do
-        f = default_formatter
-        grp.struct_defn(f)
-        fs = f.to_s
-
-        fs.should match /struct oof/
-        fs.should match /enum group_oof_type tag;/
-        fs.should match /union/
-        fs.should match /int32 aaa;/
-        fs.should match /int32 bbb;/
-        fs.should match /} data;/
-        fs.should match /};/
+      describe ".struct_defn" do
+        it "defines a structure definition" do
+          f = default_formatter
+          grp.struct_defn(f)
+          fs = f.to_s
+
+          fs.should match /struct oof/
+          fs.should match /enum group_oof_type tag;/
+          fs.should match /union/
+          fs.should match /int32_t aaa;/ # built-in types are represented as their C type
+          fs.should match /int32_t bbb;/ # built-in types are represented as their C type
+          fs.should match /No data associated with 'empty'./
+          fs.should match /} data;/
+          fs.should match /};/
+        end
       end
     end
   end