cauterize 0.0.1.pre1

data/spec/builders/c/buildable_spec.rb

@@ -0,0 +1,25 @@
+include Cauterize::Builders::C
+
+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/
+      end
+    end
+
+    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/composite_spec.rb

@@ -0,0 +1,46 @@
+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
+      end
+    end
+  end
+
+  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
+
+      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;"
+      end
+    end
+
+    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 /};/
+      end
+    end
+  end
+end

data/spec/builders/c/enumeration_spec.rb

@@ -0,0 +1,32 @@
+describe Cauterize::Builders::C::Enumeration do
+  let(:type_constructor) { lambda {|name| enumeration(name)}}
+
+  it_behaves_like "a buildable"
+  it_behaves_like "a sane buildable"
+  include_examples "no struct"
+
+  describe ".enum_defn" do
+    let(:en) do
+      _e = enumeration(:foo) do |e|
+        e.value :aaa
+        e.value :bbb
+        e.value "QuickBrownFox".to_sym
+      end
+
+      f = default_formatter
+      Builders.get(:c, _e).enum_defn(f)
+      f.to_s
+    end
+
+    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
+end

data/spec/builders/c/fixed_array_spec.rb

@@ -0,0 +1,36 @@
+describe Cauterize::Builders::C::FixedArray do
+  let(:type_constructor) do
+    scalar(:uint32_t)
+    lambda do |name|
+      fixed_array(name) do |a|
+        a.array_type :uint32_t
+        a.array_size 16
+      end
+    end
+  end
+
+  it_behaves_like "a buildable"
+  include_examples "no enum"
+  include_examples "no struct"
+
+  context "an array buildable" do
+    let(:desc_instance) { type_constructor.call(:some_type_name) }
+    let(:formatter) { default_formatter }
+    subject { described_class.new(desc_instance) }
+
+    describe :render do
+      it "contains the name" do
+        t_name = subject.instance_variable_get(:@blueprint).array_type.name
+        subject.render.should match /#{t_name}/
+      end
+    end
+
+    describe :declare 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 \*\//
+      end
+    end
+  end
+end

data/spec/builders/c/group_spec.rb

@@ -0,0 +1,112 @@
+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
+
+    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
+
+    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/
+      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
+      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/
+      end
+
+      it "contains each field" do
+        @fs.should match /dst->data\.a/
+        @fs.should match /dst->data\.b/
+      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
+
+      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;"
+      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 /};/
+      end
+    end
+  end
+end

data/spec/builders/c/scalar_spec.rb

@@ -0,0 +1,8 @@
+describe Cauterize::Builders::C::Scalar do
+  let(:type_constructor) { lambda {|name| scalar(name)}}
+
+  it_behaves_like "a buildable"
+  it_behaves_like "a sane buildable"
+  include_examples "no enum"
+  include_examples "no struct"
+end

data/spec/builders/c/variable_array_spec.rb

@@ -0,0 +1,50 @@
+describe Cauterize::Builders::C::VariableArray do
+  let(:type_constructor) do
+    lambda do |name|
+      scalar(:uint8_t)
+      variable_array(name) do |a|
+        a.array_type(:uint8_t)
+        a.array_size(8)
+        a.size_type(:uint8_t)
+      end
+    end
+  end
+
+  it_behaves_like "a buildable"
+  it_behaves_like "a sane buildable"
+  include_examples "no enum"
+
+  context "structure definition" do
+    let(:vara) do
+      scalar(:int32)
+      _a = variable_array(:va) do |a|
+        a.array_size(8)
+        a.array_type(:int32)
+        a.size_type(:int32)
+      end
+
+      Builders.get(:c, _a)
+    end
+
+    describe ".struct_proto" do
+      it "defines a structure prototype" do
+        f = default_formatter
+        vara.struct_proto(f)
+        f.to_s.should == "struct va;"
+      end
+    end
+
+    describe ".struct_defn" do
+      it "defines a structure definition" do
+        f = default_formatter
+        vara.struct_defn(f)
+        fs = f.to_s
+
+        fs.should match /struct va/
+        fs.should match /int32 length;/
+        fs.should match /int32 data\[8\];/
+        fs.should match /};/
+      end
+    end
+  end
+end

data/spec/builders_spec.rb

@@ -0,0 +1,51 @@
+describe Cauterize::Builders do
+  describe "#register and #get" do
+    let(:s) { scalar(:uint8_t) }
+    before do
+      class X; def initialize(i); end; end
+      class Y; def initialize(i); end; end
+
+      # save the old list so that we can restore it later.
+      old_builders = nil
+      Cauterize::Builders.module_exec do
+        old_builders = @builders
+        @builders = nil
+      end
+      @old_builders = old_builders
+    end
+
+    after do
+      # restore the builders so as not to break any other tests
+      old_builders = @old_builders
+      Cauterize::Builders.module_exec do
+        @builders = old_builders
+      end
+    end
+
+    it "saves and retrieves classes" do
+      Cauterize::Builders.register(:c, Cauterize::Scalar, X)
+      Cauterize::Builders.get(:c, s).class.should be X
+    end
+
+    it "handles multiple languages" do
+      Cauterize::Builders.register(:c, Cauterize::Scalar, X)
+      Cauterize::Builders.get(:c, s).class.should be X
+
+      Cauterize::Builders.register(:cs, Cauterize::Scalar, Y)
+      Cauterize::Builders.get(:cs, s).class.should be Y
+    end
+
+    it "raises an error on duplicate registrations" do
+      Cauterize::Builders.register(:c, Cauterize::Scalar, X)
+      lambda {
+        Cauterize::Builders.register(:c, Cauterize::Scalar, X)
+      }.should raise_error /already registered/
+    end
+
+    it "raises an error if no builder is registered" do
+      lambda {
+        Cauterize::Builders.get(:c, s)
+      }.should raise_error /unregistered/
+    end
+  end
+end

data/spec/c_builder_spec.rb

@@ -0,0 +1,133 @@
+require 'tmpdir'
+require 'fileutils'
+
+describe Cauterize::CBuilder do
+  before do
+    @tempdir = Dir.mktmpdir
+    @h_path = File.join(@tempdir, "testing.h")
+    @c_path = File.join(@tempdir, "testing.c")
+
+    @cb = CBuilder.new(@h_path, @c_path, "testing")
+  end
+  after { FileUtils.rm_rf @tempdir }
+
+  describe :initialize do
+    it "saves the h and c paths" do
+      @cb.h.should == @h_path
+      @cb.c.should == @c_path
+    end
+  end
+
+  describe :build do
+    before do
+      scalar(:uint8_t)
+      scalar(:uint16_t)
+      scalar(:uint32_t)
+
+      fixed_array(:mac_address) do |fa|
+        fa.array_type :uint8_t
+        fa.array_size 6
+      end
+
+      variable_array(:mac_table) do |t|
+        t.array_type :mac_address
+        t.array_size 64
+        t.size_type :uint8_t
+      end
+
+      variable_array(:name) do |va|
+        va.array_type :uint8_t
+        va.size_type :uint8_t
+        va.array_size 32
+      end
+
+      enumeration(:gender) do |e|
+        e.value :male
+        e.value :female
+      end
+
+      composite(:place) do |c|
+        c.field :name, :name
+        c.field :elevation, :uint32_t
+      end
+
+      composite(:person) do |c|
+        c.field :first_name, :name
+        c.field :last_name, :name
+        c.field :gender, :gender
+      end
+
+      composite(:dog) do |c|
+        c.field :name, :name
+        c.field :gender, :gender
+        c.field :leg_count, :uint8_t
+      end
+
+      group(:creature) do |g|
+        g.field :person, :person
+        g.field :dog, :dog
+      end
+
+      @cb.build
+      @h_text = File.read(@cb.h)
+      @h_lines = @h_text.lines.to_a
+      @c_text = File.read(@cb.c)
+      @c_lines = @c_text.lines.to_a
+    end
+
+    describe "header generation" do
+      it "prevents multiple inclusion in headers" do
+        @h_lines[0].should match /#ifndef TESTING_H_\d+/
+        @h_lines[1].should match /#define TESTING_H_\d+/
+        @h_lines.last.should match /#endif \/\* TESTING_H_\d+ \*\//
+      end
+
+      it "includes prototype information for all defined types" do
+        @h_text.should match "struct name;"
+        @h_text.should match "struct person;"
+        @h_text.should match "struct place;"
+      end
+
+      it "includes enumeration and structure definitions" do
+        @h_text.should match /gender/
+        @h_text.should match /MALE = 0/
+        @h_text.should match /FEMALE = 1/
+      end
+    end
+
+    describe "c body generation" do
+      it "includes the generated header file" do
+        @c_text.should match /#include "testing.h"/
+      end
+    end
+
+    describe "compilation" do
+      it "can be built" do
+        caut_dir = "#{File.dirname(__FILE__)}/../c/src"
+
+        res = Dir.chdir @tempdir do
+          File.open("test_main.c", "wb") do |fh|
+            syms = BaseType.all_instances.map do |i|
+              b = Builders.get(:c, i)
+              [b.packer_sym, b.unpacker_sym]
+            end.flatten
+            fh.write(gen_test_main(syms))
+          end
+
+          cmd = %W{
+            clang -Wall -Wextra -Werror
+            -I#{caut_dir}
+            #{@cb.c}
+            #{caut_dir}/cauterize.c
+            test_main.c
+            -o testing.bin 2>&1
+          }.join(" ")
+
+          `#{cmd}`
+        end
+
+        res.should == ""
+      end
+    end
+  end
+end