aaronp-zomg 1.0.2.20080827232412

data/test/conversions/test_enum.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class EnumTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          enum Foo {
+            a,
+            b
+          };
+        eoidl
+      end
+
+      def test_to_ruby_sexp
+        sexp = nil
+        ruby_sexp = [:block, [:cdecl, :Foo, [:hash, [:lit, :a], [:lit, :a], [:lit, :b], [:lit, :b]]]]
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal(ruby_sexp, sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_exception.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class ExceptionTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          exception not_implemented {};
+          exception AvocadoExcpt{
+            ::Avocado ex1;
+          };
+        eoidl
+      end
+
+      def test_to_ruby_sexp
+        sexp = nil
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal([:block, [:class, :Not_implemented, [:const, :Exception], [:scope]], [:class, :AvocadoExcpt, [:const, :Exception], [:scope, [:fcall, :attr_accessor, [:array, [:lit, :ex1]]]]]], sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_forward_declaration.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class ForwardDeclarationTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          interface A;
+        eoidl
+      end
+
+      # We don't bother with forward declarations in Ruby
+      def test_to_ruby_sexp
+        sexp = nil
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal([:block, nil], sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_interface.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class InterfaceTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          interface Foo {
+            void  a ( );
+            short b ( in short a );
+            long  c ( in short a, out IntSequence b, inout float c );
+          };
+
+          interface Bar: Foo, Baz {
+            void  d ( );
+          };
+        eoidl
+      end
+
+      def test_to_ruby_sexp
+        sexp = nil
+        ruby_sexp = [:block, [:module, :Foo, [:scope, [:block, [:defn, :a, [:scope, [:block, [:args], [:fcall, :raise, [:array, [:call, [:const, :NotImplementedError], :new]]]]]], [:defn, :b, [:scope, [:block, [:args, :a], [:fcall, :raise, [:array, [:call, [:const, :NotImplementedError], :new]]]]]], [:defn, :c, [:scope, [:block, [:args, :a, :b, :c], [:fcall, :raise, [:array, [:call, [:const, :NotImplementedError], :new]]]]]]]]], [:module, :Bar, [:scope, [:block, [:fcall, :include, [:array, [:const, :Foo], [:const, :Baz]]], [:defn, :d, [:scope, [:block, [:args], [:fcall, :raise, [:array, [:call, [:const, :NotImplementedError], :new]]]]]]]]]]
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal(ruby_sexp, sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_module.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class ModuleTest < ZOMG::Test
+      def setup
+        @parser = ZOMG::IDL::Parser.new
+      end
+    
+      def test_module
+        tree = @parser.parse(<<-eoidl)
+          module dom
+          {
+            const unsigned short INDEX_SIZE_ERR = 1;
+          };
+        eoidl
+        assert_equal(
+                [:block, [:module, :Dom, [:scope, [:block, [:cdecl, :INDEX_SIZE_ERR, [:lit, 1]]]]]],
+                tree.to_ruby_sexp
+        )
+      end
+    end
+  end
+end

data/test/conversions/test_struct.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class StructTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          struct Foo {
+            short   a;
+            long    b;
+          };
+        eoidl
+      end
+    
+      def test_to_ruby_sexp
+        sexp = nil
+        ruby_sexp = [:block, [:cdecl, :Foo, [:call, [:const, :Struct], :new, [:array, [:lit, :a], [:lit, :b]]]]]
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal(ruby_sexp, sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_typedef.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class TypedefTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          typedef long IntSequence[10];
+        eoidl
+      end
+
+      def test_to_ruby_sexp
+        sexp = nil
+        ruby_sexp = [:block, nil]
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal(ruby_sexp, sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_union.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class UnionTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          union Foo switch(long) {
+            case 10: string a;
+            case 15:
+            case 20: short  b;
+            default: char   c;
+          };
+        eoidl
+      end
+    
+      def test_to_ruby_sexp
+        sexp = nil
+        ruby_sexp = [:block, [:cdecl, :Foo, [:call, [:const, :Struct], :new, [:array, [:lit, :a], [:lit, :b], [:lit, :c]]]]]
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal(ruby_sexp, sexp)
+      end
+    end
+  end
+end

data/test/conversions/test_value_box_dcl.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+module ZOMG
+  module Conversions
+    class ValueBoxDclTest < ZOMG::Test
+      def setup
+        @tree = ZOMG::IDL.parse(<<-eoidl)
+          valuetype DOMString sequence<unsigned short>;
+        eoidl
+      end
+
+      # We don't bother with value boxes.  Yay typeless!
+      def test_to_ruby_sexp
+        sexp = nil
+        assert_nothing_raised {
+          sexp = @tree.to_ruby_sexp
+        }
+        assert_equal([:block, nil], sexp)
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'test/unit'
+require 'zomg'
+
+module ZOMG
+  class Test < Test::Unit::TestCase
+    include ZOMG::IDL::Nodes
+    ASSETS = File.expand_path(File.join(File.dirname(__FILE__), 'assets'))
+
+    undef :default_test
+
+    def assert_sexp(sexp, obj)
+      assert_equal(sexp, obj.to_sexp)
+    end
+
+    def method_missing(name, *args)
+      super unless args[0]
+      file = File.join(ASSETS, name.to_s, args[0])
+      super unless File.exists?(file)
+      file
+    end
+  end
+end

data/test/simple/test_basictypes1.rb

@@ -0,0 +1,87 @@
+require 'helper'
+
+class BasicTypes1Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('basictypes1.idl'))
+  end
+
+  def test_interface
+    assert_equal(6, @tree.children.length)
+    (_, _, _, _, _, interface) = *(@tree.children)
+    interface.children.each do |child|
+      assert_instance_of(Operation, child)
+      assert_nothing_raised {
+        child.to_sexp
+      }
+    end
+  end
+
+  def test_typedef_long
+    assert_equal(6, @tree.children.length)
+    (_, _, _, long, seq, _) = *(@tree.children)
+    assert long
+    assert seq
+
+    assert_instance_of(Typedef, long)
+    assert_instance_of(Typedef, seq)
+    assert_sexp([:typedef, :long, [[:array_decl, "IntSequence", [[:size, [:int, 10]]]]]], long)
+    assert_sexp([:typedef, [:sequence, [:long]], [[:decl, "longSeq"]]], seq)
+  end
+
+  def test_union
+    assert_equal(6, @tree.children.length)
+    (_, _, union, _, _, _) = *(@tree.children)
+    assert union
+    assert_instance_of(Union, union)
+    assert_equal('U', union.name)
+    assert_instance_of(Long, union.switch_type)
+    assert_instance_of(Array, union.children)
+    assert_equal(5, union.children.length)
+    union.children.each { |child| assert_instance_of(Case, child) }
+    [ CaseLabel,
+      CaseLabel,
+      CaseLabel,
+      CaseLabel,
+      DefaultLabel ].each_with_index { |l,i|
+        assert_instance_of(l, union.children[i].children[0])
+    }
+    assert_equal([10, 20, 50, 60], union.children.find_all { |child|
+      child.children[0].is_a?(CaseLabel)
+    }.map { |cl| cl.children[0].to_i })
+  end
+
+  def test_enum
+    assert_equal(6, @tree.children.length)
+    (_, enum, _, _, _, _) = *(@tree.children)
+    assert enum
+    assert_instance_of(Enum, enum)
+    assert_equal('Color', enum.name)
+    assert_equal(4, enum.children.length)
+    assert_equal(%w{ blue green red black }.sort, enum.children.sort)
+  end
+
+  def test_struct
+    assert_equal(6, @tree.children.length)
+    (struct, _, _, _, _, _) = *(@tree.children)
+    assert struct
+    assert_instance_of(Struct, struct)
+    assert_equal('BasicTypes', struct.name)
+    assert_instance_of(Array, struct.children)
+    assert_equal(10, struct.children.length)
+    [
+      Short,
+      UnsignedShort,
+      Long,
+      UnsignedLong,
+      Float,
+      Double,
+      Char,
+      String,
+      Boolean,
+      Octet
+    ].each_with_index do |type, i|
+      assert_instance_of(Member, struct.children[i])
+      assert_instance_of(type, struct.children[i].type)
+    end
+  end
+end

data/test/simple/test_basictypes2.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class BasicTypes2Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('basictypes2.idl'))
+  end
+
+  def test_to_sexp
+      @tree.to_sexp.flatten.each do |member|
+        assert(
+          [ ::String,
+            ::Symbol,
+            Numeric ].any? { |m| member.is_a?(m) } ||
+            [true, false, nil].any? { |m| member == m }
+              )
+      end
+  end
+end

data/test/simple/test_basictypes3.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class BasicTypes3Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('basictypes3.idl'))
+  end
+
+  def test_readonly
+    assert_sexp(
+                [:attribute, :readonly, :long, [[:decl, "l2"]]],
+                @tree.children[1].children.first
+               )
+  end
+
+  def test_header
+    i2 = @tree.children[1]
+    assert_sexp([:header, false, "ex2", [[:scoped_name, "ex1", []]]],
+                i2.header
+               )
+  end
+
+  def test_to_sexp
+      @tree.to_sexp.flatten.each do |member|
+        assert(
+          [ ::String,
+            ::Symbol,
+            Numeric ].any? { |m| member.is_a?(m) } ||
+            [true, false, nil].any? { |m| member == m }
+              )
+      end
+  end
+end

data/test/simple/test_basictypes4.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+class BasicTypes4Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('basictypes4.idl'))
+  end
+
+  def test_module_to_sexp
+    assert_sexp(
+                [:typedef, [:string, [[:int, 10]]], [[:decl, "BndString"]]],
+                @tree.duhr.Module[0].Interface[0].Typedef[0]
+               )
+  end
+
+  def test_to_sexp
+      @tree.to_sexp.flatten.each do |member|
+        assert(
+          [ ::String,
+            ::Symbol,
+            Numeric ].any? { |m| member.is_a?(m) } ||
+            [true, false, nil].any? { |m| member == m }
+              )
+      end
+  end
+end

data/test/simple/test_basictypes5.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class BasicTypes5Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('basictypes5.idl'))
+  end
+
+  def test_exception
+    assert_sexp([:exception, "not_implemented", []],
+                @tree.duhr.Exception[0]
+               )
+  end
+
+  def test_to_sexp
+    assert_nothing_raised { @tree.to_sexp }
+  end
+end

data/test/simple/test_basictypes6.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class BasicTypes6Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('basictypes6.idl'))
+  end
+
+  def test_case
+    assert_sexp([:label, [:charlit, "'L'"]],
+                @tree.duhr.Interface[0].Union[0].Case[0].CaseLabel[0]
+               )
+  end
+
+  def test_to_sexp
+    assert_nothing_raised {
+      @tree.to_sexp
+    }
+  end
+end