cauterize 0.0.1.pre1

data/spec/cauterize_spec.rb

@@ -0,0 +1,8 @@
+describe Cauterize do
+  describe :set_name do
+    it "sets the name of the project" do
+      set_name("some_name")
+      Cauterize.get_name.should == "some_name"
+    end
+  end
+end

data/spec/composite_spec.rb

@@ -0,0 +1,62 @@
+describe Cauterize do
+  before { reset_for_test }
+
+  describe CompositeField do
+    describe :initialize do
+      it "creates a new name -> type mapping" do
+        a = scalar(:a_type)
+        b = scalar(:b_type)
+        f = CompositeField.new(:a_name, :a_type)
+        f.name.should == :a_name
+        f.type.should be a
+      end
+    end
+  end
+
+  describe Composite do
+    describe :initialize do
+      it "creates a Composite" do
+        c = Composite.new(:foo)
+        c.name.should == :foo
+      end
+    end
+
+    describe :fields do
+      it "defines a new field in the composite" do
+        a = scalar(:foo)
+        comp = composite(:comp) do |c|
+          c.field :a_foo, :foo
+        end
+
+        comp.fields.keys[0].should == :a_foo
+        comp.fields.values[0].name.should == :a_foo
+        comp.fields.values[0].type.should be a
+      end
+
+      it "errors on duplicate field names" do
+        a = scalar(:foo)
+        lambda {
+          composite(:comp) do |c|
+            c.field :a_foo, :foo
+            c.field :b_foo, :foo
+            c.field :b_foo, :foo
+          end
+        }.should raise_error /Field name b_foo already used/
+      end
+    end
+  end
+
+  describe :composite do
+    it { creates_a_named_object(:composite, Composite) }
+    it { retrieves_obj_with_identical_name(:composite) }
+    it { yields_the_object(:composite) }
+    it { adds_object_to_hash(:composite, :composites) }
+  end
+
+  describe :composite! do
+    it { creates_a_named_object(:composite!, Composite) }
+    it { raises_exception_with_identical_name(:composite!) }
+    it { yields_the_object(:composite!) }
+    it { adds_object_to_hash(:composite!, :composites) }
+  end
+end

data/spec/enumeration_spec.rb

@@ -0,0 +1,104 @@
+describe Cauterize do
+  before { reset_for_test }
+
+  describe EnumerationValue do
+    describe :initialize do
+      it "creates an EnumerationValue" do
+        e = EnumerationValue.new(:foo, 1)
+        e.name.should == :foo
+        e.value.should == 1
+      end
+    end
+  end
+
+  describe Enumeration do
+    describe :initialize do
+      it "creates a new enumeration with the right name" do
+        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|
+          e.value :a
+          e.value :b
+          e.value :c
+          e.value :d
+        end
+
+        values = enum.values
+        values.length.should == 4
+        values.keys.should == [:a, :b, :c, :d]
+        values.values.map(&:value).should == [0, 1, 2, 3]
+      end
+
+      it "accepts a fixed value" do
+        enum = enumeration(:foo) do |e|
+          e.value :a, 10
+          e.value :b, 20
+          e.value :c
+        end
+
+        values = enum.values
+        values.keys.should == [:a, :b, :c]
+        values.values.map(&:value).should == [10, 20, 21]
+      end
+
+      it "allows out-of-order values" do
+        lambda {
+          enumeration(:foo) do |e|
+            e.value :a, 10
+            e.value :b, 9
+          end
+        }.should_not raise_error
+      end
+
+      it "doesn't allow duplicate ids" do
+        lambda {
+          enumeration(:foo) do |e|
+            e.value :a, 1
+            e.value :b, 1
+          end
+        }.should raise_error /duplicate constant/
+      end
+
+      it "doesn't allow accidentally identical ids" do
+        en = enumeration(:foo) do |e|
+          e.value :a, 10
+          e.value :b, 9
+          e.value :c
+        end
+
+        en.values.values.map(&:value).should == [10,9,11]
+      end
+
+      it "errors on duplicate names" do
+        lambda {
+          enumeration(:foo) do |e|
+            e.value :a
+            e.value :a
+          end
+        }.should raise_error /duplicate name/
+      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) }
+  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) }
+  end
+
+  describe :enumerations do
+    it { is_hash_of_created_objs(:enumeration, :enumerations) }
+  end
+end

data/spec/fixed_array_spec.rb

@@ -0,0 +1,62 @@
+describe Cauterize do
+  before { reset_for_test }
+
+  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) }
+  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) }
+  end
+
+  describe FixedArray do
+    before { @a = fixed_array(:foo) }
+
+    describe :initialize do
+      it "Creates a fixed array." do
+        @a.name.should == :foo
+        @a.id.should_not be_nil
+      end
+    end
+
+    describe :array_type do
+      it "Defines the type of the FixedArray." do
+        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|
+            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)
+        @a.array_type :uint32_t
+        @a.array_type.should be s
+      end
+    end
+
+    describe :array_size do
+      it "Defines the size of the FixedArray." do
+        @a.array_size 46
+        @a.instance_variable_get(:@array_size).should == 46
+      end
+
+      it "is the defined size if no argument is passed" do
+        @a.array_size 46
+        @a.array_size.should == 46
+      end
+    end
+  end
+end

data/spec/group_spec.rb

@@ -0,0 +1,104 @@
+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]
+    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
+    end
+  end
+
+  describe Group do
+    describe :initialize do
+      it "makes a new Group" do
+        Group.new(:foo).name == :foo
+      end
+
+      it "creates the tag enum" do
+        e = Group.new(:foo).tag_enum
+        e.name.should == :group_foo_type
+        e.values == {}
+      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)
+        end
+
+        grp.fields.values.map(&:name).should == [:a, :b]
+      end
+
+      it "errors on duplicate field names" do
+        a = scalar(:aaa)
+        lambda {
+          grp = 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 = 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 = scalar(:aaa)
+        b = scalar(:bbb)
+        grp = group(:foo) do |g|
+          g.field(:a, :aaa)
+          g.field(:b, :bbb)
+        end
+
+        grp.tag_enum.values.keys.should =~ [:GROUP_FOO_TYPE_A, :GROUP_FOO_TYPE_B]
+      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
+      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
+      end
+    end
+  end
+end

data/spec/scalar_spec.rb

@@ -0,0 +1,36 @@
+describe Cauterize do
+  before do
+    reset_for_test
+    flush_scalars
+  end
+
+  describe Scalar do
+    describe :initialize do
+      it "creates an scalar" do
+        scalar(:foo).name.should == :foo
+      end
+    end
+
+    describe :id do
+      it { has_a_unique_id_for_each_instance(Scalar) }
+    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) }
+  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) }
+  end
+
+  describe :scalars do
+    it { is_hash_of_created_objs(:scalar, :scalars) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,115 @@
+require 'set'
+require 'mocha/api'
+require 'require_all'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'cauterize/cauterize'
+
+require_all Dir['spec/support/**/*.rb']
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+  config.before(:each) do
+    reset_for_test
+  end
+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 = {}
+  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