cauterize 0.0.1.pre13 → 0.0.1.pre14

data/spec/builders/cs/enumeration_spec.rb

@@ -1,33 +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
-
+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

@@ -1,41 +1,41 @@
-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 /public static int MySize = 16;/
-        text.should match /protected override int Size/
-        text.should match /get { return MySize; }/
-      end
-    end
-  end
-end
+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 /public static ulong MySize = 16;/
+        text.should match /protected override ulong Size/
+        text.should match /get { return MySize; }/
+      end
+    end
+  end
+end

data/spec/builders/cs/group_spec.rb

@@ -1,56 +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.dataless(: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
+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.dataless(: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

@@ -1,7 +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
+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

@@ -1,45 +1,49 @@
-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.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
+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.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 "defines the max size" do
+        text.should match /public static ulong MyMaxSize = 16;/
+      end
+
+      it "sets the size of the array from configuration" do
+        text.should match /public MyriadData\(ulong 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 ulong MaxSize/
+        text.should match /get { return MyMaxSize; }/
+      end
+    end
+  end
+end

data/spec/builders/doc/buildable_spec.rb

@@ -1,25 +1,25 @@
-module Cauterize::Builders::Doc
-  describe Cauterize::Builders::Doc do
-    describe Buildable do
-      subject { Buildable.new(:some_blueprint) }
-
-      describe "required methods" do
-        it "raises errorson 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
-end
+module Cauterize::Builders::Doc
+  describe Cauterize::Builders::Doc do
+    describe Buildable do
+      subject { Buildable.new(:some_blueprint) }
+
+      describe "required methods" do
+        it "raises errorson 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
+end

data/spec/builders_spec.rb

@@ -1,57 +1,57 @@
-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
-        class Z; 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
-
-        Cauterize::Builders.register(:ruby, Cauterize::Scalar, Z)
-        Cauterize::Builders.get(:ruby, s).class.should be Z
-      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 exception no builder is registered" do
-        lambda {
-          Cauterize::Builders.get(:c, s)
-        }.should raise_error Cauterize::Builders::UnregisteredException
-      end
-    end
-  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
+        class Z; 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
+
+        Cauterize::Builders.register(:ruby, Cauterize::Scalar, Z)
+        Cauterize::Builders.get(:ruby, s).class.should be Z
+      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 exception no builder is registered" do
+        lambda {
+          Cauterize::Builders.get(:c, s)
+        }.should raise_error Cauterize::Builders::UnregisteredException
+      end
+    end
+  end
+end