cauterize 0.0.1.pre1 → 0.0.1.pre5

data/spec/builders/c/scalar_spec.rb

@@ -1,8 +1,26 @@
-describe Cauterize::Builders::C::Scalar do
-  let(:type_constructor) { lambda {|name| scalar(name)}}
+module Cauterize
+  describe Cauterize::Builders::C::Scalar do
+    let(:type_constructor) {
+      lambda {
+        |name| Cauterize.scalar(name) {
+          |t| t.type_name(:int32)
+        }
+      }
+    }
 
-  it_behaves_like "a buildable"
-  it_behaves_like "a sane buildable"
-  include_examples "no enum"
-  include_examples "no struct"
+    describe ".typedef_decl" do
+      it "declares the type synonym" do
+        s = Cauterize.scalar(:zeep) {|t| t.type_name(:int32)}
+
+        f = default_formatter
+        Builders.get(:c, s).typedef_decl(f)
+        f.to_s.should == "typedef int32_t zeep;"
+      end
+    end
+
+    it_behaves_like "a buildable"
+    it_behaves_like "a sane buildable"
+    include_examples "no enum"
+    include_examples "no struct"
+  end
 end

data/spec/builders/c/variable_array_spec.rb

@@ -1,49 +1,49 @@
-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)
+module Cauterize
+  describe Cauterize::Builders::C::VariableArray do
+    let(:type_constructor) do
+      lambda do |name|
+        Cauterize.variable_array(name) do |a|
+          a.array_type(:uint8)
+          a.array_size(8)
+          a.size_type(:uint8)
+        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(:vara) do
-      scalar(:int32)
-      _a = variable_array(:va) do |a|
-        a.array_size(8)
-        a.array_type(:int32)
-        a.size_type(:int32)
-      end
+    context "structure definition" do
+      let(:vara) do
+        _a = Cauterize.variable_array(:va) do |a|
+          a.array_size(8)
+          a.array_type(:int32)
+          a.size_type(:int32)
+        end
 
-      Builders.get(:c, _a)
-    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;"
+      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
-    end
 
-    describe ".struct_defn" do
-      it "defines a structure definition" do
-        f = default_formatter
-        vara.struct_defn(f)
-        fs = f.to_s
+      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 /};/
+          fs.should match /struct va/
+          fs.should match /int32_t length;/
+          fs.should match /int32_t data\[8\];/
+          fs.should match /};/
+        end
       end
     end
   end

data/spec/builders/cs/buildable_spec.rb

@@ -0,0 +1,8 @@
+include Cauterize::Builders::CS
+
+describe Cauterize::Builders::CS do
+  describe Buildable do
+    subject { Buildable.new(:some_blueprint) }
+    pending "nothing to test until packing"
+  end
+end

data/spec/builders/cs/composite_spec.rb

@@ -0,0 +1,32 @@
+module Cauterize
+  describe Cauterize::Builders::CS::Composite do
+    context "class definition" do
+      let(:comp) do
+        Cauterize.scalar(:int32_t) {|t| t.type_name(:int32) }
+        Cauterize.scalar(:int16_t) {|t| t.type_name(:int16) }
+        _c = Cauterize.composite(:foo) do |c|
+          c.field(:an_int, :int32_t)
+          c.field(:a_short, :int16_t)
+        end
+
+        Builders.get(:cs, _c)
+      end
+
+      describe ".class_defn" do
+        it "defines a class for the composite" do
+          f = four_space_formatter
+          comp.class_defn(f)
+          f.to_s.should == <<EOS
+public class Foo : CauterizeComposite
+{
+    [Order(0)]
+    public Int32 AnInt { get; set; }
+    [Order(1)]
+    public Int16 AShort { get; set; }
+}
+EOS
+        end
+      end
+    end
+  end
+end

data/spec/builders/cs/enumeration_spec.rb

@@ -0,0 +1,33 @@
+module Cauterize
+  describe Cauterize::Builders::CS::Enumeration do
+    describe ".enum_defn" do
+      let(:en) do
+        _e = Cauterize.enumeration(:foo) do |e|
+          e.value :aaa
+          e.value :bbb
+          e.value "quick_brown_fox".to_sym
+        end
+
+        f = default_formatter
+        Builders.get(:cs, _e).enum_defn(f)
+        f.to_s
+      end
+
+      it "contains the serialized representation annotation" do
+        en.should match /\[SerializedRepresentation\(typeof\(SByte\)\)\]/
+      end
+
+      it "contains the enum name" do
+        en.should match /public enum Foo/
+      end
+
+      it "contains an entry for each value" do
+        en.should match /Aaa = 0,/
+        en.should match /Bbb = 1,/
+        en.should match /QuickBrownFox = 2,/
+        en.should match /};/
+      end
+    end
+  end
+end
+

data/spec/builders/cs/fixed_array_spec.rb

@@ -0,0 +1,40 @@
+describe Cauterize::Builders::CS::FixedArray do
+
+  context "array class definition" do
+    let(:fixed_arr) do
+      Cauterize.scalar(:uint32_t) {|t| t.type_name(:uint32)}
+      _fa = Cauterize.fixed_array(:myriad_data) do |a|
+        a.array_type :uint32_t
+        a.array_size 16
+      end
+
+      Cauterize::Builders.get(:cs, _fa)
+    end
+
+    describe ".class_defn" do
+      let(:text) do
+        f = four_space_formatter
+        fixed_arr.class_defn(f)
+        text = f.to_s
+      end
+      it "defines a class for the array" do
+        text.should match /public class MyriadData : CauterizeFixedArrayTyped<UInt32>/
+      end
+
+      it "sets the size of the array from configuration" do
+        text.should match /public MyriadData\(\)/ # no args
+        text.should match /Allocate\(16\);/
+      end
+
+      it "allows defaulting an array" do
+        text.should match /public MyriadData\(UInt32\[\] data\)/
+        text.should match /Allocate\(data\);/
+      end
+
+      it "defines a size" do
+        text.should match /protected override int Size/
+        text.should match /get { return 16; }/
+      end
+    end
+  end
+end

data/spec/builders/cs/group_spec.rb

@@ -0,0 +1,56 @@
+module Cauterize
+  describe Cauterize::Builders::CS::Group do
+    context "enumeration for type tag" do
+      before do
+        Cauterize.scalar(:uint8_t) {|t| t.type_name(:uint8)}
+        @g = Cauterize.group!(:some_name) do |_g|
+          _g.field(:a, :uint8_t)
+          _g.field(:b, :uint8_t)
+          _g.field(:c)
+          _g.field(:d, :uint8_t)
+        end
+        @b = Cauterize::Builders::CS::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,
+                                    :GROUP_SOME_NAME_TYPE_C,
+                                    :GROUP_SOME_NAME_TYPE_D ]
+        end
+      end
+
+      describe ".class_defn" do
+        it "defines an enum and class" do
+          f = four_space_formatter
+          @b.class_defn(f)
+          fs = f.to_s
+
+          fs.should == <<EOS
+public class SomeName : CauterizeGroup
+{
+    [Order(0)]
+    public GroupSomeNameType Type { get; set; }
+
+    [Order(1)]
+    public Byte A { get; set; }
+    [Order(2)]
+    public Byte B { get; set; }
+    /* No data associated with 'c'. */
+    [Order(4)]
+    public Byte D { get; set; }
+}
+EOS
+        end
+      end
+    end
+  end
+end

data/spec/builders/cs/scalar_spec.rb

@@ -0,0 +1,7 @@
+module Cauterize
+  describe Cauterize::Builders::CS::Scalar do
+    let(:type_constructor) { lambda {|name| Cauterize.scalar(name)}}
+
+    pending "base buildable tests for csharp"
+  end
+end

data/spec/builders/cs/variable_array_spec.rb

@@ -0,0 +1,46 @@
+describe Cauterize::Builders::CS::VariableArray do
+
+  context "array class definition" do
+    let(:var_arr) do
+      Cauterize.scalar(:uint32_t) {|t| t.type_name(:uint32)}
+      Cauterize.scalar(:uint8_t) {|t| t.type_name(:uint8)}
+      _va = Cauterize.variable_array(:myriad_data) do |a|
+        a.size_type :uint8_t
+        a.array_type :uint32_t
+        a.array_size 16
+      end
+
+      Cauterize::Builders.get(:cs, _va)
+    end
+
+    describe ".class_defn" do
+      let(:text) do
+        f = four_space_formatter
+        var_arr.class_defn(f)
+        text = f.to_s
+      end
+      it "defines a class for the array" do
+        text.should match /public class MyriadData : CauterizeVariableArrayTyped<UInt32>/
+      end
+
+      it "defines the size type" do
+        text.should match /public static Type SizeType = typeof\(Byte\);/
+      end
+
+      it "sets the size of the array from configuration" do
+        text.should match /public MyriadData\(int size\)/ # no args
+        text.should match /Allocate\(size\);/
+      end
+
+      it "allows defaulting an array" do
+        text.should match /public MyriadData\(UInt32\[\] data\)/
+        text.should match /Allocate\(data\);/
+      end
+
+      it "defines a max size" do
+        text.should match /protected override int MaxSize/
+        text.should match /get { return Byte\.MaxValue; }/
+      end
+    end
+  end
+end

data/spec/builders_spec.rb

@@ -1,51 +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
+module Cauterize
+  describe Cauterize::Builders do
+    describe "#register and #get" do
+      let(:s) { Cauterize.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
+        # 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
-      @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
+      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
-    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 "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
+      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
+        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 {
+      it "raises an error on duplicate registrations" do
         Cauterize::Builders.register(:c, Cauterize::Scalar, X)
-      }.should raise_error /already registered/
-    end
+        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/
+      it "is nil if no builder is registered" do
+        Cauterize::Builders.get(:c, s).should be_nil
+      end
     end
   end
 end

data/spec/builtin_spec.rb

@@ -0,0 +1,46 @@
+module Cauterize
+
+  describe BuiltIn do
+    describe :initialize do
+      it "creates a builtin" do
+        b = BuiltIn.new(:foo)
+        b.is_signed(false)
+        b.byte_length(4)
+        
+        b.name.should == :foo
+        b.is_signed.should == false
+        b.byte_length.should == 4
+      end
+    end
+
+    describe :id do
+     it "has a unique id for each builtin" do
+       ids = Cauterize.builtins.values.map(&:id)
+       ids.uniq.should =~ ids
+     end
+    end
+  end
+
+
+  # Since the builtins are static, we make sure they are all defined here. They
+  # should be created as part of the loading process. This is kinda evil.
+  describe :builtins do
+    Cauterize.builtins.keys.should =~ [
+      :int8, :int16, :int32, :int64,
+      :uint8, :uint16, :uint32, :uint64,
+    ]
+  end
+
+  # We should not provide a way for people to build more builtin types directly.
+  # This test ensures that there isn't a method to do so, but only by checking
+  # that we haven't added the convention.
+  #
+  # I know, I know, testing negative behavior.
+  describe :builtin do
+    it "should not exist" do
+      lambda {
+        Cauterize.builtin(:foo)
+      }.should raise_error /undefined method/
+    end
+  end
+end