cauterize 0.0.1.pre13 → 0.0.1.pre14

data/lib/cauterize/representation.rb

@@ -1,32 +1,32 @@
-class Representation
-  def self.lengthRepresentation(max_length)
-    if max_length < 2**8
-      Cauterize::BaseType.find_type!(:uint8)
-    elsif max_length < 2**16
-      Cauterize::BaseType.find_type!(:uint16)
-    elsif max_length < 2**32
-      Cauterize::BaseType.find_type!(:uint32)
-    elsif max_length < 2**64
-      Cauterize::BaseType.find_type!(:uint64)
-    else
-      raise Exception.new("Unable to represent array length (#{max_length}).")
-    end
-  end
-
-  def self.enumRepresentation(args)
-    max_val = args[:max]
-    min_val = args[:min]
-    
-    if -128 <= min_val and max_val <= 127
-      Cauterize::BaseType.find_type!(:int8)
-    elsif (-32768 <= min_val and max_val <= 32767)
-      Cauterize::BaseType.find_type!(:int16)
-    elsif (-2147483648 <= min_val and max_val <= 2147483647)
-      Cauterize::BaseType.find_type!(:int32)
-    elsif (-9223372036854775808 <= min_val and max_val <= 9223372036854775807)
-      Cauterize::BaseType.find_type!(:int64)
-    else
-      raise Exception.new("Unable to represent enumeration (#{min_val} -> #{max_val})")
-    end
-  end
-end
+class Representation
+  def self.lengthRepresentation(max_length)
+    if max_length < 2**8
+      Cauterize::BaseType.find_type!(:uint8)
+    elsif max_length < 2**16
+      Cauterize::BaseType.find_type!(:uint16)
+    elsif max_length < 2**32
+      Cauterize::BaseType.find_type!(:uint32)
+    elsif max_length < 2**64
+      Cauterize::BaseType.find_type!(:uint64)
+    else
+      raise Exception.new("Unable to represent array length (#{max_length}).")
+    end
+  end
+
+  def self.enumRepresentation(args)
+    max_val = args[:max]
+    min_val = args[:min]
+    
+    if -128 <= min_val and max_val <= 127
+      Cauterize::BaseType.find_type!(:int8)
+    elsif (-32768 <= min_val and max_val <= 32767)
+      Cauterize::BaseType.find_type!(:int16)
+    elsif (-2147483648 <= min_val and max_val <= 2147483647)
+      Cauterize::BaseType.find_type!(:int32)
+    elsif (-9223372036854775808 <= min_val and max_val <= 9223372036854775807)
+      Cauterize::BaseType.find_type!(:int64)
+    else
+      raise Exception.new("Unable to represent enumeration (#{min_val} -> #{max_val})")
+    end
+  end
+end

data/lib/cauterize/ruby_builder.rb

@@ -1,44 +1,44 @@
-require 'time'
-
-module Cauterize
-  class RubyBuilder
-    attr_reader :rb
-    def initialize(rb_file, name="cauterize")
-      @rb = rb_file
-      @name = name.camel
-    end
-
-    def build
-      build_rb
-    end
-
-    def build_rb
-      f = []
-
-      f << "# WARNING: This is generated code. Do not edit this file directly."
-      f << ""
-      f << "require_relative './cauterize_ruby_builtins'"
-      f << ""
-      f << "module #{Cauterize.get_name.camel}"
-      f << ""
-      f << "  CAUTERIZE_GEN_VERSION = \"#{Cauterize.get_version}\""
-      f << "  CAUTERIZE_GEN_DATE = \"#{DateTime.now.to_s}\""
-      f << ""
-
-      f << "  CAUTERIZE_MODEL_HASH_LEN = #{BaseType.digest_class.new.length}"
-      f << "  CAUTERIZE_MODEL_HASH = [#{BaseType.model_hash.bytes.to_a.join(", ")}]"
-      f << ""
-
-      instances = BaseType.all_instances
-      builders = instances.map {|i| Builders.get(:ruby, i)}
-      builders.each { |b| b.class_defn(f) }
-      f << "end"
-      f << ""
-
-      File.open(@rb, "wb") do |fh|
-        fh.write(f.join("\n").to_s)
-      end
-    end
-
-  end
-end
+require 'time'
+
+module Cauterize
+  class RubyBuilder
+    attr_reader :rb
+    def initialize(rb_file, name="cauterize")
+      @rb = rb_file
+      @name = name.camel
+    end
+
+    def build
+      build_rb
+    end
+
+    def build_rb
+      f = []
+
+      f << "# WARNING: This is generated code. Do not edit this file directly."
+      f << ""
+      f << "require_relative './cauterize_ruby_builtins'"
+      f << ""
+      f << "module #{Cauterize.get_name.camel}"
+      f << ""
+      f << "  CAUTERIZE_GEN_VERSION = \"#{Cauterize.get_version}\""
+      f << "  CAUTERIZE_GEN_DATE = \"#{DateTime.now.to_s}\""
+      f << ""
+
+      f << "  CAUTERIZE_MODEL_HASH_LEN = #{BaseType.digest_class.new.length}"
+      f << "  CAUTERIZE_MODEL_HASH = [#{BaseType.model_hash.bytes.to_a.join(", ")}]"
+      f << ""
+
+      instances = BaseType.all_instances
+      builders = instances.map {|i| Builders.get(:ruby, i)}
+      builders.each { |b| b.class_defn(f) }
+      f << "end"
+      f << ""
+
+      File.open(@rb, "wb") do |fh|
+        fh.write(f.join("\n").to_s)
+      end
+    end
+
+  end
+end

data/lib/cauterize/scalar.rb

@@ -1,53 +1,53 @@
-# scalar.rb
-#
-# scalars are types that, in C, can be updated with assignment. This includes
-# native types in C and typedefs around these native types.
-#
-# scalars are not structs, enumerations, unions, or arrays.
-
-module Cauterize
-  module_function
-
-  def scalar(name, desc=nil)
-    a = Cauterize.scalars[name] || Cauterize.scalars[name] = Scalar.new(name, desc)
-    yield a if block_given?
-    return a
-  end
-
-  def scalar!(name, &blk)
-    if Cauterize.scalars[name]
-      raise Exception.new("Scalar with name #{name} already exists.")
-    else
-      Cauterize.scalar(name, &blk)
-    end
-  end
-
-  def scalars
-    @scalars ||= {}
-  end
-
-  class Scalar < BaseType
-    def initialize(name, desc=nil)
-      super
-    end
-
-    def type_name(type_name = nil)
-      if type_name
-        t = BaseType.find_type!(type_name)
-        if t.class != BuiltIn
-          raise Exception.new("Must specify a BuiltIn type for scalars.")
-        end
-
-        @type_name = t
-      else
-        @type_name
-      end
-    end
-
-    protected
-
-    def local_hash(digest)
-      @type_name.type_hash(digest)
-    end
-  end
-end
+# scalar.rb
+#
+# scalars are types that, in C, can be updated with assignment. This includes
+# native types in C and typedefs around these native types.
+#
+# scalars are not structs, enumerations, unions, or arrays.
+
+module Cauterize
+  module_function
+
+  def scalar(name, desc=nil)
+    a = Cauterize.scalars[name] || Cauterize.scalars[name] = Scalar.new(name, desc)
+    yield a if block_given?
+    return a
+  end
+
+  def scalar!(name, &blk)
+    if Cauterize.scalars[name]
+      raise Exception.new("Scalar with name #{name} already exists.")
+    else
+      Cauterize.scalar(name, &blk)
+    end
+  end
+
+  def scalars
+    @scalars ||= {}
+  end
+
+  class Scalar < BaseType
+    def initialize(name, desc=nil)
+      super
+    end
+
+    def type_name(type_name = nil)
+      if type_name
+        t = BaseType.find_type!(type_name)
+        if t.class != BuiltIn
+          raise Exception.new("Must specify a BuiltIn type for scalars.")
+        end
+
+        @type_name = t
+      else
+        @type_name
+      end
+    end
+
+    protected
+
+    def local_hash(digest)
+      @type_name.type_hash(digest)
+    end
+  end
+end

data/lib/cauterize/snake_case.rb

@@ -1,21 +1,21 @@
-class String
-  def snake
-    self.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_")
-  end
-
-  def up_snake
-    snake.upcase
-  end
-
-  def down_snake
-    snake.downcase
-  end
-
-  def camel
-    return self.capitalize if self !~ /_/ && self =~ /[A-z]+.*/
-    split('_').map{|e| e.capitalize}.join
-  end
-end
+class String
+  def snake
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_")
+  end
+
+  def up_snake
+    snake.upcase
+  end
+
+  def down_snake
+    snake.downcase
+  end
+
+  def camel
+    return self.capitalize if self !~ /_/ && self =~ /[A-z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+end

data/lib/cauterize/variable_array.rb

@@ -1,55 +1,55 @@
-module Cauterize
-  module_function
-
-  def variable_array(name, desc=nil)
-    a = Cauterize.variable_arrays[name] || Cauterize.variable_arrays[name] = VariableArray.new(name, desc)
-    yield a if block_given?
-    return a
-  end
-
-  def variable_array!(name, &blk)
-    if Cauterize.variable_arrays[name]
-      raise Exception.new("VariableArray with name #{name} already exists.")
-    else
-      Cauterize.variable_array(name, &blk)
-    end
-  end
-
-  def variable_arrays
-    @variable_arrays ||= {}
-  end
-
-  class VariableArray < BaseType
-    def intialize(name, desc=nil)
-      super
-    end
-
-    def array_type(t = nil)
-      if t
-        @array_type = BaseType.find_type!(t)
-      else
-        @array_type
-      end
-    end
-
-    def array_size(s = nil)
-      if s
-        @array_size = s
-      else
-        @array_size
-      end
-    end
-
-    def size_type
-      Representation.lengthRepresentation(@array_size)
-    end
-
-    protected
-
-    def local_hash(digest)
-      digest.update(@array_size.to_s)
-      @array_type.type_hash(digest)
-      size_type.type_hash(digest)
-    end
-  end
-end
+module Cauterize
+  module_function
+
+  def variable_array(name, desc=nil)
+    a = Cauterize.variable_arrays[name] || Cauterize.variable_arrays[name] = VariableArray.new(name, desc)
+    yield a if block_given?
+    return a
+  end
+
+  def variable_array!(name, &blk)
+    if Cauterize.variable_arrays[name]
+      raise Exception.new("VariableArray with name #{name} already exists.")
+    else
+      Cauterize.variable_array(name, &blk)
+    end
+  end
+
+  def variable_arrays
+    @variable_arrays ||= {}
+  end
+
+  class VariableArray < BaseType
+    def intialize(name, desc=nil)
+      super
+    end
+
+    def array_type(t = nil)
+      if t
+        @array_type = BaseType.find_type!(t)
+      else
+        @array_type
+      end
+    end
+
+    def array_size(s = nil)
+      if s
+        @array_size = s
+      else
+        @array_size
+      end
+    end
+
+    def size_type
+      Representation.lengthRepresentation(@array_size)
+    end
+
+    protected
+
+    def local_hash(digest)
+      digest.update(@array_size.to_s)
+      @array_type.type_hash(digest)
+      size_type.type_hash(digest)
+    end
+  end
+end

data/lib/cauterize/version.rb

@@ -1,3 +1,3 @@
-module Cauterize
-  VERSION = "0.0.1.pre13"
-end
+module Cauterize
+  VERSION = "0.0.1.pre14"
+end

data/spec/base_type_spec.rb

@@ -1,251 +1,251 @@
-module Cauterize
-
-  describe Cauterize do
-    describe BaseType do
-      describe :description do
-        it "handles nil description" do
-          BaseType.new(:foo, nil).description.should be_nil
-        end
-
-        it "sets the description" do
-          BaseType.new(:foo, "a desc").description.should == "a desc"
-        end
-      end
-
-      describe :register_instance do
-        it "adds an instance to the instance list" do
-          orig_len = BaseType.all_instances.length
-
-          class X < BaseType
-            def initialize(name); end
-          end
-          x = X.new(:foo)
-
-          x.instance_exec do
-            register_instance(x)
-          end
-
-          BaseType.all_instances.last.should be x
-          BaseType.all_instances.length.should == orig_len + 1
-        end
-      end
-
-      describe :instances do
-        # Two things are being tested here.
-        # 1. That instances works.
-        # 2. That super() is called in each .new
-        it "is every instance of a BaseType-derived class" do
-          BaseType.class_variable_set(:@@instances, {})
-
-          b = BuiltIn.new(:uint32)
-          s = Scalar.new(:eek)
-          e = Enumeration.new(:emoo)
-          c = Composite.new(:cooo)
-          f = FixedArray.new(:moo)
-          v = VariableArray.new(:quack)
-          g = Group.new(:goo)
-
-          lst = [b, s, e, c, f, v, g]
-
-          instances = BaseType.all_instances
-
-          # There will be some extras due to automatic creation of enums and
-          # scalars in Enumeration and Group.
-          instances.should include(*lst)
-
-          # Check that each of our instances shows up in the list returned from
-          # all_instances. Do it this way in case there are other types created
-          # (like the enumeration for Group).
-          lst.all? do |l|
-            instances.any? {|i| i.equal? l}
-          end
-        end
-      end
-
-      describe :type_hash do
-        it "is different for objects with different names" do
-          f = Cauterize.scalar(:foo) {|t| t.type_name :uint8}.type_hash
-          g = Cauterize.scalar(:bar) {|t| t.type_name :uint8}.type_hash
-
-          f.should_not == g
-        end
-
-        it "is different for objects with different types" do
-          f = Cauterize.scalar(:foo) {|t| t.type_name :uint8}.type_hash
-          reset_for_test
-
-          g = Cauterize.scalar(:foo) {|t| t.type_name :int8}.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-
-        it "differes on enumeration value differences" do
-          f = Cauterize.enumeration(:foo) { |t| t.value :a, 0 }.type_hash
-          reset_for_test
-
-          g = Cauterize.enumeration(:foo) { |t| t.value :a, 1 }.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-
-        it "differs on differing length in fixed arrays" do
-          f = Cauterize.fixed_array(:foo) { |t| t.array_type :int8; t.array_size 1 }.type_hash
-          reset_for_test
-
-          g = Cauterize.fixed_array(:foo) { |t| t.array_type :int8; t.array_size 2 }.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-
-        it "differs on differing size type in variable arrays" do
-          f = Cauterize.variable_array(:foo) { |t| t.array_type :int8; t.array_size 2 }.type_hash
-          reset_for_test
-
-          g = Cauterize.variable_array(:foo) { |t| t.array_type :int8; t.array_size 2000 }.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-
-        it "differs on group field reordering" do
-          f = Cauterize.group(:foo) do |t|
-            t.field :a, :int8
-            t.field :b, :int8
-          end.type_hash
-          reset_for_test
-
-          g = Cauterize.group(:foo) do |t|
-            t.field :b, :int8
-            t.field :a, :int8
-          end.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-
-        it "differs on composite field reordering" do
-          f = Cauterize.composite(:foo) do |t|
-            t.field :a, :int8
-            t.field :b, :int8
-          end.type_hash
-          reset_for_test
-
-          g = Cauterize.composite(:foo) do |t|
-            t.field :b, :int8
-            t.field :a, :int8
-          end.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-
-        it "differs on changes in indirect fields" do
-          Cauterize.scalar(:a_thing) { |t| t.type_name :int8 }
-          f = Cauterize.composite(:foo) do |t|
-            t.field :a, :a_thing
-          end.type_hash
-          reset_for_test
-
-          Cauterize.scalar(:a_thing) { |t| t.type_name :uint8 }
-          g = Cauterize.composite(:foo) do |t|
-            t.field :a, :a_thing
-          end.type_hash
-          reset_for_test
-
-          f.should_not == g
-        end
-      end
-
-      describe :model_hash do
-        it "returns a SHA1 of the model" do
-          Cauterize.scalar(:foo) {|t| t.type_name :uint8}
-
-          h = BaseType.model_hash
-          h.should_not be_nil
-          h.length.should == 20 # length of sha1
-        end
-
-        it "is supported by all the types" do
-          gen_a_model
-          h = BaseType.model_hash
-          h.should_not be_nil
-          h.length.should == 20 # length of sha1
-        end
-
-        it "differs on different models" do
-          gen_a_model
-          a = BaseType.model_hash
-          reset_for_test
-
-          gen_b_model
-          b = BaseType.model_hash
-          reset_for_test
-
-          a.should_not == b
-        end
-      end
-
-      describe :find_type do
-        it "returns the instance with the provided name" do
-          f = Cauterize.scalar(:foo)
-          b = Cauterize.scalar(:bar)
-
-          BaseType.find_type(:bar).should be b
-          BaseType.find_type(:foo).should be f
-        end
-
-        it "is nil on an unknown name" do
-          BaseType.find_type(:xxxxxxxxxxxxxxxxxx).should be_nil
-        end
-      end
-
-      describe :find_type! do
-        it "returns the instance with the provided name" do
-          f = Cauterize.scalar(:foo)
-          b = Cauterize.scalar(:bar)
-
-          BaseType.find_type!(:bar).should be b
-          BaseType.find_type!(:foo).should be f
-        end
-
-        it "errors on an unknown name" do
-          lambda { BaseType.find_type!(:foo) }.should raise_error /name foo does not/
-        end
-      end
-
-      describe "is_[type]?" do
-        it "supports scalar" do
-          Cauterize.scalar(:foo).is_scalar?.should be_true
-        end
-
-        it "supports enumeration" do
-          Cauterize.enumeration(:foo).is_enumeration?.should be_true
-        end
-
-        it "supports composite" do
-          Cauterize.composite(:foo).is_composite?.should be_true
-        end
-
-        it "supports fixed_array" do
-          Cauterize.fixed_array(:foo).is_fixed_array?.should be_true
-        end
-
-        it "supports variable_array" do
-          Cauterize.variable_array(:foo).is_variable_array?.should be_true
-        end
-
-        it "supports group" do
-          Cauterize.group(:foo).is_group?.should be_true
-        end
-
-        it "supports builtin" do
-          # This one is special because of how buitins are declared
-          Cauterize.builtins[:int32].is_built_in?.should be_true
-        end
-      end
-    end
-  end
-end
+module Cauterize
+
+  describe Cauterize do
+    describe BaseType do
+      describe :description do
+        it "handles nil description" do
+          BaseType.new(:foo, nil).description.should be_nil
+        end
+
+        it "sets the description" do
+          BaseType.new(:foo, "a desc").description.should == "a desc"
+        end
+      end
+
+      describe :register_instance do
+        it "adds an instance to the instance list" do
+          orig_len = BaseType.all_instances.length
+
+          class X < BaseType
+            def initialize(name); end
+          end
+          x = X.new(:foo)
+
+          x.instance_exec do
+            register_instance(x)
+          end
+
+          BaseType.all_instances.last.should be x
+          BaseType.all_instances.length.should == orig_len + 1
+        end
+      end
+
+      describe :instances do
+        # Two things are being tested here.
+        # 1. That instances works.
+        # 2. That super() is called in each .new
+        it "is every instance of a BaseType-derived class" do
+          BaseType.class_variable_set(:@@instances, {})
+
+          b = BuiltIn.new(:uint32)
+          s = Scalar.new(:eek)
+          e = Enumeration.new(:emoo)
+          c = Composite.new(:cooo)
+          f = FixedArray.new(:moo)
+          v = VariableArray.new(:quack)
+          g = Group.new(:goo)
+
+          lst = [b, s, e, c, f, v, g]
+
+          instances = BaseType.all_instances
+
+          # There will be some extras due to automatic creation of enums and
+          # scalars in Enumeration and Group.
+          instances.should include(*lst)
+
+          # Check that each of our instances shows up in the list returned from
+          # all_instances. Do it this way in case there are other types created
+          # (like the enumeration for Group).
+          lst.all? do |l|
+            instances.any? {|i| i.equal? l}
+          end
+        end
+      end
+
+      describe :type_hash do
+        it "is different for objects with different names" do
+          f = Cauterize.scalar(:foo) {|t| t.type_name :uint8}.type_hash
+          g = Cauterize.scalar(:bar) {|t| t.type_name :uint8}.type_hash
+
+          f.should_not == g
+        end
+
+        it "is different for objects with different types" do
+          f = Cauterize.scalar(:foo) {|t| t.type_name :uint8}.type_hash
+          reset_for_test
+
+          g = Cauterize.scalar(:foo) {|t| t.type_name :int8}.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+
+        it "differes on enumeration value differences" do
+          f = Cauterize.enumeration(:foo) { |t| t.value :a, 0 }.type_hash
+          reset_for_test
+
+          g = Cauterize.enumeration(:foo) { |t| t.value :a, 1 }.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+
+        it "differs on differing length in fixed arrays" do
+          f = Cauterize.fixed_array(:foo) { |t| t.array_type :int8; t.array_size 1 }.type_hash
+          reset_for_test
+
+          g = Cauterize.fixed_array(:foo) { |t| t.array_type :int8; t.array_size 2 }.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+
+        it "differs on differing size type in variable arrays" do
+          f = Cauterize.variable_array(:foo) { |t| t.array_type :int8; t.array_size 2 }.type_hash
+          reset_for_test
+
+          g = Cauterize.variable_array(:foo) { |t| t.array_type :int8; t.array_size 2000 }.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+
+        it "differs on group field reordering" do
+          f = Cauterize.group(:foo) do |t|
+            t.field :a, :int8
+            t.field :b, :int8
+          end.type_hash
+          reset_for_test
+
+          g = Cauterize.group(:foo) do |t|
+            t.field :b, :int8
+            t.field :a, :int8
+          end.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+
+        it "differs on composite field reordering" do
+          f = Cauterize.composite(:foo) do |t|
+            t.field :a, :int8
+            t.field :b, :int8
+          end.type_hash
+          reset_for_test
+
+          g = Cauterize.composite(:foo) do |t|
+            t.field :b, :int8
+            t.field :a, :int8
+          end.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+
+        it "differs on changes in indirect fields" do
+          Cauterize.scalar(:a_thing) { |t| t.type_name :int8 }
+          f = Cauterize.composite(:foo) do |t|
+            t.field :a, :a_thing
+          end.type_hash
+          reset_for_test
+
+          Cauterize.scalar(:a_thing) { |t| t.type_name :uint8 }
+          g = Cauterize.composite(:foo) do |t|
+            t.field :a, :a_thing
+          end.type_hash
+          reset_for_test
+
+          f.should_not == g
+        end
+      end
+
+      describe :model_hash do
+        it "returns a SHA1 of the model" do
+          Cauterize.scalar(:foo) {|t| t.type_name :uint8}
+
+          h = BaseType.model_hash
+          h.should_not be_nil
+          h.length.should == 20 # length of sha1
+        end
+
+        it "is supported by all the types" do
+          gen_a_model
+          h = BaseType.model_hash
+          h.should_not be_nil
+          h.length.should == 20 # length of sha1
+        end
+
+        it "differs on different models" do
+          gen_a_model
+          a = BaseType.model_hash
+          reset_for_test
+
+          gen_b_model
+          b = BaseType.model_hash
+          reset_for_test
+
+          a.should_not == b
+        end
+      end
+
+      describe :find_type do
+        it "returns the instance with the provided name" do
+          f = Cauterize.scalar(:foo)
+          b = Cauterize.scalar(:bar)
+
+          BaseType.find_type(:bar).should be b
+          BaseType.find_type(:foo).should be f
+        end
+
+        it "is nil on an unknown name" do
+          BaseType.find_type(:xxxxxxxxxxxxxxxxxx).should be_nil
+        end
+      end
+
+      describe :find_type! do
+        it "returns the instance with the provided name" do
+          f = Cauterize.scalar(:foo)
+          b = Cauterize.scalar(:bar)
+
+          BaseType.find_type!(:bar).should be b
+          BaseType.find_type!(:foo).should be f
+        end
+
+        it "errors on an unknown name" do
+          lambda { BaseType.find_type!(:foo) }.should raise_error /name foo does not/
+        end
+      end
+
+      describe "is_[type]?" do
+        it "supports scalar" do
+          Cauterize.scalar(:foo).is_scalar?.should be_true
+        end
+
+        it "supports enumeration" do
+          Cauterize.enumeration(:foo).is_enumeration?.should be_true
+        end
+
+        it "supports composite" do
+          Cauterize.composite(:foo).is_composite?.should be_true
+        end
+
+        it "supports fixed_array" do
+          Cauterize.fixed_array(:foo).is_fixed_array?.should be_true
+        end
+
+        it "supports variable_array" do
+          Cauterize.variable_array(:foo).is_variable_array?.should be_true
+        end
+
+        it "supports group" do
+          Cauterize.group(:foo).is_group?.should be_true
+        end
+
+        it "supports builtin" do
+          # This one is special because of how buitins are declared
+          Cauterize.builtins[:int32].is_built_in?.should be_true
+        end
+      end
+    end
+  end
+end