aaronp-zomg 1.0.2.20080827232412

data/test/simple/test_simple1.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+class Simple1Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('simple1.idl'))
+  end
+
+  def test_parse_simple1
+    assert_instance_of(Specification, @tree)
+    assert_equal(1, @tree.children.length)
+
+    idl_module = @tree.children.first
+    assert_instance_of(Module, idl_module)
+    assert_equal('OneWaySimpleTest', idl_module.name)
+
+    assert_equal(1, idl_module.children.length)
+    idl_interface = idl_module.children.first
+    assert_instance_of(Interface, idl_interface)
+    assert_equal('sim1wcor', idl_interface.header.name)
+
+    assert_equal(1, idl_interface.children.length)
+    idl_op_decl = idl_interface.children.first
+    assert_equal('OneWayMethod', idl_op_decl.name)
+    assert_equal(:void, idl_op_decl.returns.to_sexp)
+    assert_equal('oneway', idl_op_decl.attribute)
+
+    assert_equal(2, idl_op_decl.children.length)
+
+    idl_op_decl.children.each do |child|
+      assert_instance_of(Parameter, child)
+      assert_equal(:in, child.attribute.to_sexp)
+    end
+
+    in_str  = idl_op_decl.children.first
+    in_long = idl_op_decl.children[1]
+
+    assert_equal('inStr', in_str.name)
+    assert_equal('inLong', in_long.name)
+  end
+end

data/test/simple/test_simple2.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+class Simple2Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('simple2.idl'))
+  end
+
+  def test_parse_simple2
+    assert_instance_of(Specification, @tree)
+    assert_equal(1, @tree.children.length)
+
+    idl_module = @tree.children.first
+    assert_instance_of(Module, idl_module)
+    assert_equal('TwoWaySimpleTest', idl_module.name)
+
+    assert_equal(2, idl_module.children.length)
+    exception = idl_module.children[0]
+    assert_instance_of(Exception, exception)
+    assert_equal('SimpleEx', exception.name)
+
+    idl_interface = idl_module.children[1]
+    assert_instance_of(Interface, idl_interface)
+    assert_equal('sim2wcor', idl_interface.header.name)
+
+    assert_equal(1, idl_interface.children.length)
+    idl_op_decl = idl_interface.children.first
+    assert_equal('TwoWayMethod', idl_op_decl.name)
+    assert_instance_of(String, idl_op_decl.returns)
+    assert_nil(idl_op_decl.attribute)
+    assert_equal(1, idl_op_decl.raises.length)
+    assert_equal('SimpleEx', idl_op_decl.raises.first.name)
+
+    assert_equal(3, idl_op_decl.children.length)
+    idl_op_decl.children.each do |child|
+      assert_instance_of(Parameter, child)
+    end
+    assert_equal([:in, :in_out, :out], idl_op_decl.children.map { |x|
+      x.attribute.to_sexp
+    })
+    assert_equal( [String, Long, UnsignedShort],
+      idl_op_decl.children.map { |x|
+        x.type.class
+    })
+    assert_equal(%w{ inStr inoutLong outUShort }, idl_op_decl.children.map { |x|
+      x.name
+    })
+  end
+end

data/test/simple/test_simple3.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class Simple3Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(simple('simple3.idl'))
+  end
+
+  def test_parse_tree
+    assert_equal(1, @tree.children.length)
+    idl_module = @tree.children.first
+    assert_equal(1, idl_module.children.length)
+
+    interface = idl_module.children.first
+    assert_equal(1, interface.children.length)
+    attribute = interface.children.first
+    assert_instance_of(Attribute, attribute)
+    assert_equal(1, attribute.children.length)
+    assert_equal('test', attribute.children.first.name)
+  end
+end

data/test/test_array.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class Array1Test < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(array('array1.idl'))
+  end
+  
+  def test_string_sequence
+    assert_sexp(
+      [:typedef, [:sequence, [[:scoped_name, "arr", []], [:int, 2]]], [[:decl, "arrseq"]]], @tree.duhr.Typedef[7])
+  end
+
+  def test_forward_declaration
+    assert_sexp([:forward_decl, 'foo'], @tree.duhr.ForwardDeclaration[0])
+  end
+
+  def test_to_sexp
+    assert_nothing_raised {
+      @tree.to_sexp
+    }
+  end
+end

data/test/test_assets.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+module ZOMG
+  module AssetTests
+  end
+end
+
+Dir[File.join(ZOMG::Test::ASSETS, '*')].each do |dir|
+  next unless File.directory?(dir)
+  klass = Class.new(ZOMG::Test) {
+    Dir[File.join(dir, '*.idl')].each do |file|
+      name = File.basename(file)
+      define_method(:setup) do
+        @tree = ZOMG::IDL::Parser.parse_file(file)
+      end
+
+      define_method(:"test_#{name.gsub('.', '_')}_to_sexp") do
+        assert_nothing_raised {
+          @tree.to_sexp
+        }
+      end
+
+      define_method(:"test_#{name.gsub('.', '_')}_to_ruby") do
+        ruby = nil
+        assert_nothing_raised { ruby = @tree.to_ruby }
+        x = Module.new
+        assert_nothing_raised { x.module_eval(ruby) }
+      end
+    end
+  }
+  test_name = File.basename(dir)
+  ZOMG::AssetTests.const_set(:"#{test_name.capitalize}Test", klass)
+end

data/test/test_complex.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class ComplexTest < ZOMG::Test
+  COMPLEX = File.join(ASSETS, 'complex')
+
+  def test_constant_sexp
+    tree = ZOMG::IDL::Parser.parse_file(complex('complex4.idl'))
+    assert_sexp([:const, [:scoped_name, "longT", []], "long_c", [:int, 1]],
+                tree.duhr.Constant[0])
+  end
+
+  def test_context_sexp
+    tree = ZOMG::IDL::Parser.parse_file(complex('TestIntfContext.idl'))
+    operation = tree.duhr.Module[0].Interface[0].Operation[0].tree
+    assert_sexp([:context, [[:string_lit, ["\"A*\""]], [:string_lit, ["\"C*\""]], [:string_lit, ["\"X\""]], [:string_lit, ["\"Z\""]]]], operation.context)
+  end
+end

data/test/test_node.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class NodeTest < ZOMG::Test
+  def setup
+    @tree = ZOMG::IDL::Parser.parse_file(array('array1.idl'))
+  end
+
+  def test_to_ruby
+    assert_nothing_raised {
+      @tree.to_ruby
+    }
+    ruby_with_prefix = @tree.to_ruby('A::B')
+    assert_match(/module A/, ruby_with_prefix)
+    assert_match(/module B/, ruby_with_prefix)
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class ParserTest < ZOMG::Test
+  def setup
+    @parser = ZOMG::IDL::Parser.new
+  end
+
+  def test_valuetype
+    tree = @parser.parse(<<-eoidl)
+      module dom
+      {
+        valuetype DOMString sequence<unsigned short>;
+      };
+    eoidl
+    assert_nothing_raised { tree.to_sexp }
+  end
+end

data/test/test_scanner.rb

@@ -0,0 +1,234 @@
+require 'helper'
+
+class ScannerTest < ZOMG::Test
+  def setup
+    @scanner = ZOMG::IDL::Scanner.new
+  end
+
+  def test_load_file
+    @scanner.load_file(simple('simple1.idl'))
+    tokens = []
+    while token = @scanner.next_token
+      tokens << token
+    end
+    assert tokens.length > 0
+  end
+
+  def test_typedef_object
+    assert_tokens([
+                  [:T_TYPEDEF, "typedef"],
+                  [:T_OBJECT, "Object"],
+                  [:T_IDENTIFIER, "ObjectAlias"],
+    ], 'typedef Object ObjectAlias;')
+  end
+
+  def test_const_long
+    assert_tokens([
+                  [:T_CONST, "const"],
+                  [:T_LONG, "long"],
+                  [:T_IDENTIFIER, "ConstLong"],
+                  [:T_EQUAL, "="],
+                  [:T_MINUS_SIGN, "-"],
+    ], 'const long ConstLong = -1234;')
+  end
+
+  def test_escaped_string
+    assert_tokens([
+                  [:T_CONST, "const"],
+                  [:T_CHAR, "char"],
+                  [:T_IDENTIFIER, "ConstChar5"],
+                  [:T_EQUAL, "="],
+                  [:T_CHARACTER_LITERAL, "'\\''"],
+    ], 'const char ConstChar5 = \'\\\'\'')
+  end
+
+  def test_vertical_pipe
+    assert_tokens([
+                  [:T_CONST, "const"],
+                  [:T_LONG, "long"],
+                  [:T_IDENTIFIER, "ConstLong"],
+                  [:T_EQUAL, "="],
+                  [:T_LEFT_PARANTHESIS, "("],
+                  [:T_INTEGER_LITERAL, "0xf"],
+                  [:T_VERTICAL_LINE, "|"],
+    ], "const long ConstLong = (0xf | 0xf000) & 0xfffe")
+  end
+
+  def test_instr
+    assert_tokens([
+                  [:T_IN, "in"],
+                  [:T_STRING, "string"],
+                  [:T_IDENTIFIER, "inStr"],
+    ], "in string inStr")
+  end
+
+  def test_comment
+    assert_tokens([[:T_COMMENT, "// boner"]], "// boner")
+    assert_tokens([[:T_COMMENT, "/* boner */"]], "/* boner */")
+  end
+
+  def test_pragma
+    assert_tokens([[:T_PRAGMA, "#pragma awesome\n"]], "#pragma awesome\n")
+  end
+
+  def test_preprocessor_directive
+    assert_tokens([[:T_PREPROCESSOR, "#awesome\n"]], "#awesome\n")
+  end
+
+  def test_curlies
+    assert_tokens([[:T_LEFT_CURLY_BRACKET, "{"]], "{")
+    assert_tokens([[:T_RIGHT_CURLY_BRACKET, "}"]], "}")
+    assert_tokens([
+      [:T_LEFT_CURLY_BRACKET, "{"],
+      [:T_RIGHT_CURLY_BRACKET, "}"]
+    ], "{ }\n")
+  end
+
+  def test_squares
+    assert_tokens([[:T_LEFT_SQUARE_BRACKET, "["]], "[")
+    assert_tokens([[:T_RIGHT_SQUARE_BRACKET, "]"]], "]")
+    assert_tokens([
+      [:T_LEFT_SQUARE_BRACKET, "["],
+      [:T_RIGHT_SQUARE_BRACKET, "]"]
+    ], " [ ] \n")
+  end
+
+  def test_parens
+    assert_tokens([[:T_LEFT_PARANTHESIS, "("]], "(")
+    assert_tokens([[:T_RIGHT_PARANTHESIS, ")"]], ")")
+    assert_tokens([
+      [:T_LEFT_PARANTHESIS, "("],
+      [:T_RIGHT_PARANTHESIS, ")"]
+    ], " ( ) \n")
+  end
+
+  # Test literals
+  {
+    :const        => [:T_CONST, 'const'],
+    :typedef      => [:T_TYPEDEF, 'typedef'],
+    :float        => [:T_FLOAT, 'float'],
+    :double       => [:T_DOUBLE, 'double'],
+    :char         => [:T_CHAR, 'char'],
+    :wchar        => [:T_WCHAR, 'wchar'],
+    :fixed        => [:T_FIXED, 'fixed'],
+    :boolean      => [:T_BOOLEAN, 'boolean'],
+    :string       => [:T_STRING, 'string'],
+    :wstring      => [:T_WSTRING, 'wstring'],
+    :void         => [:T_VOID, 'void'],
+    :unsigned     => [:T_UNSIGNED, 'unsigned'],
+    :long         => [:T_LONG, 'long'],
+    :short        => [:T_SHORT, 'short'],
+    :struct       => [:T_STRUCT, 'struct'],
+    :union        => [:T_UNION, 'union'],
+    :switch       => [:T_SWITCH, 'switch'],
+    :case         => [:T_CASE, 'case'],
+    :default      => [:T_DEFAULT, 'default'],
+    :enum         => [:T_ENUM, 'enum'],
+    :in           => [:T_IN, 'in'],
+    :out          => [:T_OUT, 'out'],
+    :interface    => [:T_INTERFACE, 'interface'],
+    :abstract     => [:T_ABSTRACT, 'abstract'],
+    :valuetype    => [:T_VALUETYPE, 'valuetype'],
+    :truncatable  => [:T_TRUNCATABLE, 'truncatable'],
+    :supports     => [:T_SUPPORTS, 'supports'],
+    :custom       => [:T_CUSTOM, 'custom'],
+    :public       => [:T_PUBLIC, 'public'],
+    :private      => [:T_PRIVATE, 'private'],
+    :factory      => [:T_FACTORY, 'factory'],
+    :native       => [:T_NATIVE, 'native'],
+    :module       => [:T_MODULE, 'module'],
+    :octet        => [:T_OCTET, 'octet'],
+    :any          => [:T_ANY, 'any'],
+    :sequence     => [:T_SEQUENCE, 'sequence'],
+    :readonly     => [:T_READONLY, 'readonly'],
+    :attribute    => [:T_ATTRIBUTE, 'attribute'],
+    :exception    => [:T_EXCEPTION, 'exception'],
+    :oneway       => [:T_ONEWAY, 'oneway'],
+    :inout        => [:T_INOUT, 'inout'],
+    :raises       => [:T_RAISES, 'raises'],
+    :context      => [:T_CONTEXT, 'context'],
+  }.each do |type, token|
+    define_method(:"test_#{type}") do
+      parse_text = token.length == 3 ? token.pop : token.last
+      assert_tokens([token], parse_text)
+      assert_tokens([
+        [:T_LEFT_SQUARE_BRACKET, "["],
+        token,
+        [:T_RIGHT_SQUARE_BRACKET, "]"]
+      ], " [\n#{parse_text}] \n")
+      assert_tokens([
+                    [:T_IN, "in"],
+                    [:T_STRING, "string"],
+                    [:T_IDENTIFIER, "#{parse_text}Str"],
+      ], "in string #{parse_text}Str")
+    end
+  end
+
+  {
+    :minus        => [:T_MINUS_SIGN, '-'],
+    :plus         => [:T_PLUS_SIGN, '+'],
+    :shift_left   => [:T_SHIFTLEFT, '<<'],
+    :shift_right  => [:T_SHIFTRIGHT, '>>'],
+    :equal        => [:T_EQUAL, '='],
+    :semicolon    => [:T_SEMICOLON, ';'],
+    :comma        => [:T_COMMA, ','],
+    :colon        => [:T_COLON, ':'],
+    :asterisk     => [:T_ASTERISK, '*'],
+    :solidus      => [:T_SOLIDUS, '/'],
+    :percent      => [:T_PERCENT_SIGN, '%'],
+    :tilde        => [:T_TILDE, '~'],
+    :pipe         => [:T_VERTICAL_LINE, '|'],
+    :caret        => [:T_CIRCUMFLEX, '^'],
+    :ampersand    => [:T_AMPERSAND, '&'],
+    :less_than    => [:T_LESS_THAN_SIGN, '<'],
+    :greater_than => [:T_GREATER_THAN_SIGN, '>'],
+    :FALSE        => [:T_FALSE, 'FALSE'],
+    :TRUE         => [:T_TRUE, 'TRUE'],
+    :ValueBase    => [:T_VALUEBASE, 'ValueBase'],
+    :scope        => [:T_SCOPE, '::'],
+    :object       => [:T_OBJECT, 'Object'],
+    :principal    => [:T_PRINCIPAL, 'Principal'],
+    :identifier   => [:T_IDENTIFIER, 'hello'],
+    :float_lit_1  => [:T_FLOATING_PT_LITERAL, '123.2e10'],
+    :float_lit_11 => [:T_FLOATING_PT_LITERAL, '123.2E10'],
+    :float_lit_2  => [:T_FLOATING_PT_LITERAL, '123.0E-5', '123.E-5'],
+    :float_lit_3  => [:T_FLOATING_PT_LITERAL, '123e10'],
+    :float_lit_31 => [:T_FLOATING_PT_LITERAL, '123E+10'],
+    :float_lit_4  => [:T_FLOATING_PT_LITERAL, '12.2'],
+    :float_lit_5  => [:T_FLOATING_PT_LITERAL, '12.0', '12.'],
+    :float_lit_6  => [:T_FLOATING_PT_LITERAL, '0.12e10', '.12e10'],
+    :float_lit_61 => [:T_FLOATING_PT_LITERAL, '0.12e+10', '.12e+10'],
+    :float_lit_7  => [:T_FLOATING_PT_LITERAL, '0.12', '.12'],
+    :fixed_lit_1  => [:T_FIXED_PT_LITERAL, '123', '123d'],
+    :fixed_lit_2  => [:T_FIXED_PT_LITERAL, '123', '123.d'],
+    :fixed_lit_21 => [:T_FIXED_PT_LITERAL, '123', '123.D'],
+    :fixed_lit_3  => [:T_FIXED_PT_LITERAL, '0.123', '.123d'],
+    :fixed_lit_31 => [:T_FIXED_PT_LITERAL, '0.123', '.123D'],
+    :fixed_lit_4  => [:T_FIXED_PT_LITERAL, '0.123', '0.123d'],
+    :fixed_lit_41 => [:T_FIXED_PT_LITERAL, '0.123', '0.123D'],
+    :hex_lit      => [:T_INTEGER_LITERAL, '0x23'],
+    :hex_lit_1    => [:T_INTEGER_LITERAL, '0X23'],
+    :oct_lit      => [:T_INTEGER_LITERAL, '023'],
+    :int_lit      => [:T_INTEGER_LITERAL, '23'],
+    :char_lit     => [:T_CHARACTER_LITERAL, "'a'"],
+    :string_lit   => [:T_STRING_LITERAL, '"abc"'],
+    :unknown      => [:T_UNKNOWN, '.'],
+  }.each do |type, token|
+    define_method(:"test_#{type}") do
+      parse_text = token.length == 3 ? token.pop : token.last
+      assert_tokens([token], parse_text)
+      assert_tokens([
+        [:T_LEFT_SQUARE_BRACKET, "["],
+        token,
+        [:T_RIGHT_SQUARE_BRACKET, "]"]
+      ], " [\n#{parse_text}] \n")
+    end
+  end
+
+  def assert_tokens(tokens, string)
+    @scanner.scan_evaluate(string)
+    tokens.each do |token|
+      assert_equal(token, @scanner.next_token)
+    end
+  end
+end