ClsRuby 1.0.0

data/tests/tc_lexer_char_classifier.rb

@@ -0,0 +1,121 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) )
+
+require 'stringio'
+require 'test/unit'
+
+require 'cls-ruby/lexers/char_classifier'
+
+class TC_LexerCharClassifier < Test::Unit::TestCase
+  EOF = ClsRuby::Lexers::CharClassifier::EOF
+
+  def test_empty
+    parse_and_compare( "", [] )
+  end
+
+  def test_simple
+    parse_and_compare( 'abc',
+      [
+        [ 'a', :tok_nonspace ],
+        [ 'b', :tok_nonspace ],
+        [ 'c', :tok_nonspace ]
+      ] )
+  end
+
+  def test_comments
+    parse_and_compare( '||',
+      [ [ '||', :tok_space ] ] )
+    parse_and_compare( "||abc",
+      [ [ '||abc', :tok_space ] ] )
+    parse_and_compare( "||abc\n1 2",
+      [ [ "||abc\n", :tok_space ],
+        [ '1', :tok_nonspace ],
+        [ ' ', :tok_space ],
+        [ '2', :tok_nonspace ]
+      ] )
+
+    parse_and_compare( "|##|",
+      [ [ '|##|', :tok_space ] ] )
+    parse_and_compare( "|###|",
+      [ [ '|###|', :tok_space ] ] )
+    parse_and_compare( "|#\n#|",
+      [ [ "|#\n#|", :tok_space ] ] )
+    parse_and_compare( "|######\n\t######|",
+      [ [ "|######\n\t######|", :tok_space ] ] )
+    parse_and_compare( "|#\\n#|",
+      [ [ "|#\\n#|", :tok_space ] ] )
+    parse_and_compare( "|#\\x0A#|",
+      [ [ "|#\n#|", :tok_space ] ] )
+  end
+
+  def test_escapes
+    parse_and_compare(
+        '\\\\ \\{ \\} \\| \\n \\t \\r { }',
+        [ [ '\\', :tok_nonspace ],
+          [ ' ', :tok_space ],
+          [ '{', :tok_nonspace ],
+          [ ' ', :tok_space ],
+          [ '}', :tok_nonspace ],
+          [ ' ', :tok_space ],
+          [ '|', :tok_nonspace ],
+          [ ' ', :tok_space ],
+          [ "\n", :tok_space ],
+          [ ' ', :tok_space ],
+          [ "\t", :tok_space ],
+          [ ' ', :tok_space ],
+          [ "\r", :tok_space ],
+          [ ' ', :tok_space ],
+          [ '{', :tok_open_block ],
+          [ ' ', :tok_space ],
+          [ '}', :tok_close_block ] ] )
+  end
+
+  def test_strings
+    parse_and_compare( '""',
+        [ [ '', :tok_string ] ] )
+
+    parse_and_compare( '"abc"',
+        [ [ 'abc', :tok_string ] ] )
+
+    parse_and_compare(
+        '"ab|cd"' + '"ab\\|cd"' + '"a{b}"' + '"a\\{b\\}"' +
+            '"a\"b"',
+        [ [ 'ab|cd', :tok_string ],
+          [ 'ab|cd', :tok_string ],
+          [ 'a{b}', :tok_string ],
+          [ 'a{b}', :tok_string ],
+          [ 'a"b', :tok_string ] ] )
+  end
+
+  def test_exceptions
+    assert_raise( ClsRuby::InvalidVerticalBarSeqEx ) do
+      parse_string( "|-" )
+    end
+    assert_raise( ClsRuby::UnclosedVerticalBarSeqEx ) do
+      parse_string( "|" )
+    end
+    assert_raise( ClsRuby::UnclosedMultilineCommentEx ) do
+      parse_string( "|# # #" )
+    end
+
+    assert_raise( ClsRuby::InvalidEscapeSeqEx ) do
+      parse_string( "\\d" )
+    end
+  end
+
+private
+  def parse_and_compare( source, expected )
+    result = parse_string( source )
+    assert_equal( expected, result )
+  end
+
+  def parse_string( string )
+    result = []
+    lexer = ClsRuby::Lexers::CharClassifier.new( StringIO.new( string ), '-' )
+    while EOF != ( n = lexer.next )
+      result << n
+    end
+
+    result
+  end
+end
+

data/tests/tc_lexer_first_stage.rb

@@ -0,0 +1,72 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) )
+
+require 'stringio'
+require 'test/unit'
+
+require 'cls-ruby/lexers/first_stage'
+
+class TC_LexerFirstStage < Test::Unit::TestCase
+  def test_empty
+    parse_and_compare( "", "" )
+  end
+
+  def test_simple
+    parse_and_compare( 'abc', 'abc' )
+  end
+
+  def test_non_digital_escapes
+    source = '\\\\ \n \r \t \| \{ \}'
+    parse_and_compare( source, source )
+  end
+
+  def test_hex_escapes
+    parse_and_compare(
+        '\\xaa \\xAA \\Xaa \\XAA \\xA \\x0 \\xAAA',
+        "\xaa \xAA \xaa \xAA \xa \x0 \xAAA" )
+  end
+
+  def test_oct_escapes
+    parse_and_compare(
+        '\\o123 \\O123 \\o12 \\O12 \\o1 \\O1 \\o1234',
+        "\123 \123 \12 \12 \1 \1 \1234" )
+  end
+
+  def test_bin_escapes
+    parse_and_compare(
+        '\\b00010001 \\B00010001 \\b1 \\B1 \\b000100011',
+        "\x11 \x11 \x1 \x1 \x111" )
+  end
+
+  def test_unclosed_escape_seq
+    assert_raise( ClsRuby::UnclosedEscapeSeqEx ) do
+      parse_string( "\\" )
+    end
+  end
+
+  def test_empty_digital_escape_seq
+    assert_raise( ClsRuby::UnclosedEscapeSeqEx ) do
+      parse_string( "\\x" )
+    end
+
+    assert_raise( ClsRuby::UnclosedEscapeSeqEx ) do
+      parse_string( "\\x----" )
+    end
+  end
+
+private
+  def parse_and_compare( source, expected )
+    result = parse_string( source )
+    assert_equal( expected, result )
+  end
+
+  def parse_string( string )
+    result = ''
+    lexer = ClsRuby::Lexers::FirstStage.new( StringIO.new( string ), '-' )
+    while n = lexer.next
+      result << n
+    end
+
+    result
+  end
+end
+

data/tests/tc_parser_simple.rb

@@ -0,0 +1,93 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) )
+
+require 'stringio'
+require 'test/unit'
+
+require 'cls-ruby/parser'
+
+class TC_ParserSimple < Test::Unit::TestCase
+  def test_empty
+    assert_nothing_raised do ClsRuby.parse_string( '' ) end
+  end
+
+  def test_empty_with_one_optional_tag
+    assert_nothing_raised do
+      ClsRuby.parse_string(
+          '',
+          ClsRuby::Tag.new( :name => 'sample' ) )
+    end
+  end
+
+  def test_empty_with_one_mandatory_tag
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby.parse_string( '',
+          ClsRuby::Tag.new(
+              :name => 'sample',
+              :mandatory => true ) )
+    end
+  end
+
+  def test_one_tag
+    assert_nothing_raised do
+      ClsRuby.parse_string(
+          ' {sample} ',
+          ClsRuby::Tag.new(
+              :name => 'sample',
+              :mandatory => true ) )
+    end
+  end
+
+  def test_string_at_top_level
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby.parse_string( ' "ssnns" ' )
+    end
+  end
+
+  def test_nonspace_at_top_level
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby.parse_string( ' ssnns ' )
+    end
+  end
+
+  def test_nested_tag_when_disabled
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby.parse_string( '{sample {some-tag}}',
+          ClsRuby::Tag.new(
+              :name => 'sample',
+              :mandatory => true ) )
+    end
+  end
+
+  def test_nested_tags_when_enabled
+    parent = ClsRuby::Tag.new( :name => 'parent' )
+    first = ClsRuby::Tag.new( :name => 'first', :owner => parent )
+    second = ClsRuby::Tag.new( :name => 'second', :owner => parent )
+
+    assert_nothing_raised do
+      ClsRuby.parse_string( '{parent {first} {second}}', parent )
+    end
+
+    assert_equal( true, parent.tag_defined? )
+    assert_equal( true, first.tag_defined? )
+    assert_equal( true, second.tag_defined? )
+  end
+
+  def test_unclosed_tag
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby.parse_string( '{sample',
+          ClsRuby::Tag.new(
+              :name => 'sample',
+              :mandatory => true ) )
+    end
+  end
+
+  def test_to_many_closing_tags
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby.parse_string( '{sample}}',
+          ClsRuby::Tag.new(
+              :name => 'sample',
+              :mandatory => true ) )
+    end
+  end
+end
+

data/tests/tc_scalar_parsers.rb

@@ -0,0 +1,189 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) )
+
+require 'test/unit'
+
+require 'cls-ruby/basic_scalars'
+
+class TC_IntegerScalars < Test::Unit::TestCase
+  def initialize( *args )
+    super( *args )
+
+    @format = ClsRuby::SCALAR_INT
+  end
+
+  def test_zero
+    assert_equal( 0, @format.on_tok_nonspace( '0' ) )
+    assert_equal( 0, @format.on_tok_nonspace( '00' ) )
+    assert_equal( 0, @format.on_tok_nonspace( '+0' ) )
+    assert_equal( 0, @format.on_tok_nonspace( '-0' ) )
+  end
+
+  def test_sign
+    assert_equal( 1, @format.on_tok_nonspace( '1' ) )
+    assert_equal( -1, @format.on_tok_nonspace( '-1') )
+    assert_equal( +1, @format.on_tok_nonspace( '+1') )
+  end
+
+  def test_decimal
+    data = { '1' => 1, '10' => 10, '01' => 1,
+        '010' => 10, '11' => 11, '110' => 110 }
+
+    data.each do |k, v|
+      assert_equal( v, @format.on_tok_nonspace( k ), "parsing #{k}" )
+      assert_equal( -v, @format.on_tok_nonspace( '-' + k ), "parsing -#{k}" )
+      assert_equal( v, @format.on_tok_nonspace( k.upcase ),
+          "parsing #{k.upcase}" )
+      assert_equal( -v, @format.on_tok_nonspace( '-' + k.upcase ),
+          "parsing -#{k.upcase}" )
+    end
+  end
+
+  def test_binary
+    data = { '0b0' => 0, '0b00' => 0, '0b01' => 1,
+        '0b10' => 2, '0b11' => 3, '0b110' => 6 }
+
+    data.each do |k, v|
+      assert_equal( v, @format.on_tok_nonspace( k ), "parsing #{k}" )
+      assert_equal( v, @format.on_tok_nonspace( k.upcase ),
+          "parsing #{k.upcase}" )
+    end
+  end
+
+  def test_octal
+    data = { '0o0' => 0, '0o00' => 0, '0o01' => 1,
+        '0o10' => 8, '0o11' => 9, '0o110' => 72 }
+
+    data.each do |k, v|
+      assert_equal( v, @format.on_tok_nonspace( k ), "parsing #{k}" )
+      assert_equal( v, @format.on_tok_nonspace( k.upcase ),
+          "parsing #{k.upcase}" )
+    end
+  end
+
+  def test_hex
+    data = { '0x0' => 0, '0x00' => 0, '0x01' => 1,
+        '0x10' => 16, '0x11' => 17, '0x110' => 272 }
+
+    data.each do |k, v|
+      assert_equal( v, @format.on_tok_nonspace( k ), "parsing #{k}" )
+      assert_equal( v, @format.on_tok_nonspace( k.upcase ),
+          "parsing #{k.upcase}" )
+    end
+  end
+
+  def test_failures
+    data = [ '0b', '0o', '0x', '0x1G', '0o778' ]
+
+    data.each do |v|
+      assert_raise( ClsRuby::InvalidValueEx, "parsing #{v}" ) do
+        @format.on_tok_nonspace( v )
+      end
+    end
+  end
+end
+
+class TC_UnsignedIntegerScalars < Test::Unit::TestCase
+  def initialize( *args )
+    super( *args )
+
+    @format = ClsRuby::SCALAR_UINT
+  end
+
+  def test_zero
+    assert_equal( 0, @format.on_tok_nonspace( '0' ) )
+    assert_equal( 0, @format.on_tok_nonspace( '00' ) )
+  end
+
+  def test_decimal
+    data = { '1' => 1, '10' => 10, '01' => 1,
+        '010' => 10, '11' => 11, '110' => 110 }
+
+    data.each do |k, v|
+      assert_equal( v, @format.on_tok_nonspace( k ), "parsing #{k}" )
+      assert_equal( v, @format.on_tok_nonspace( k.upcase ),
+          "parsing #{k.upcase}" )
+    end
+  end
+end
+
+class TC_FloatingPointScalars < Test::Unit::TestCase
+  def initialize( *args )
+    super( *args )
+
+    @format = ClsRuby::SCALAR_FLOAT
+  end
+
+  def test_zero
+    values = [ '0', '0.0', '.0', '0.0e0', '.0e0', '0.0e+0', '0.0e-0' ]
+
+    values.each do |v|
+      assert_equal( 0.0, @format.on_tok_nonspace( v ), "parsing #{v}" )
+
+      n = '-' + v
+      assert_equal( 0.0, @format.on_tok_nonspace( n ), "parsing #{n}" )
+
+      n = '+' + v
+      assert_equal( 0.0, @format.on_tok_nonspace( n ), "parsing #{n}" )
+    end
+  end
+
+  def test_values
+    data = { '45' => 45.0, '4.5e1' => 45.0, '0.45e2' => 45.0,
+             '4.5e+1' => 45.0, '0.45e+2' => 45.0, '.45e+2' => 45.0,
+             '45e-1' => 4.5, '45.0e-1' => 4.5 }
+
+    data.each do |k, v|
+      assert_equal( v, @format.on_tok_nonspace( k ), "parsing #{k}" )
+
+      assert_equal( -v, @format.on_tok_nonspace( '-' + k ), "parsing -#{k}" )
+    end
+  end
+end
+
+class TC_TimeXmlSchemaScalars < Test::Unit::TestCase
+  def initialize( *args )
+    super( *args )
+
+    @format_no_fraction = ClsRuby::TimeXmlSchemaScalarParser.new
+    @format_fraction_3 = ClsRuby::TimeXmlSchemaScalarParser.new( 3 )
+  end
+
+  def test_normal
+    time_initializers = [ 2006, 12, 23, 11, 43, 15, 345000 ]
+    t = Time.utc( *time_initializers )
+
+    v_no_fraction = @format_no_fraction.format( t )
+    assert_equal( '"2006-12-23T11:43:15Z"', v_no_fraction )
+
+    v_fraction_3 = @format_fraction_3.format( t )
+    assert_equal( '"2006-12-23T11:43:15.345Z"', v_fraction_3 )
+
+    assert_equal(
+        Time.utc( *(time_initializers[ 0, time_initializers.size - 1 ]) ),
+        @format_no_fraction.on_tok_string(
+            v_no_fraction[ 1, v_no_fraction.size - 2 ] ) )
+
+    assert_equal(
+        t,
+        @format_no_fraction.on_tok_string(
+            v_fraction_3[ 1, v_fraction_3.size - 2 ] ) )
+    assert_equal(
+        t,
+        @format_fraction_3.on_tok_string(
+            v_fraction_3[ 1, v_fraction_3.size - 2 ] ) )
+  end
+
+  def test_localtime
+    time_initializers = [ 2006, 12, 23, 11, 43, 15, 345000 ]
+    t = Time.utc( *time_initializers ).getlocal
+
+    v_fraction_3 = @format_fraction_3.format( t )
+    assert_equal( '"2006-12-23T11:43:15.345Z"', v_fraction_3 )
+
+    assert_equal(
+        t,
+        @format_fraction_3.on_tok_string(
+            v_fraction_3[ 1, v_fraction_3.size - 2 ] ) )
+  end
+end
+

data/tests/tc_tag.rb

@@ -0,0 +1,68 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) )
+
+require 'test/unit'
+
+require 'cls-ruby/tag'
+
+class TC_TagDefaultParams < Test::Unit::TestCase
+  class First < ClsRuby::Tag
+    default_tag_params :name => 'first'
+  end
+
+  class Second < First
+    default_tag_params :name => 'second', :mandatory => true
+  end
+
+  class Third < Second
+    default_tag_params :mandatory => false
+  end
+
+  class HandleOptParam < ClsRuby::Tag
+    attr_reader :value
+
+    def initialize( params = {} )
+      super( params )
+
+      tag_handle_opt_param( :value ) do |v|
+        @value = v
+        tag_make_defined
+      end
+    end
+  end
+
+  def test_first
+    t1 = First.new( {} )
+    t2 = First.new( :name => 't2' )
+
+    assert_equal( 'first', t1.tag_name )
+    assert_equal( 't2', t2.tag_name )
+  end
+
+  def test_second
+    t1 = Second.new( {} )
+    t2 = Second.new( :name => 't2', :mandatory => false )
+
+    assert_equal( 'second', t1.tag_name )
+    assert_equal( true, t1.tag_mandatory? )
+
+    assert_equal( 't2', t2.tag_name )
+    assert_equal( false, t2.tag_mandatory? )
+  end
+
+  def test_third
+    t = Third.new( {} )
+
+    assert_equal( 'second', t.tag_name )
+    assert_equal( false, t.tag_mandatory? )
+  end
+
+  def test_handle_opt_param
+    t1 = HandleOptParam.new
+    assert_equal( false, t1.tag_defined? )
+
+    t2 = HandleOptParam.new( :value => 'some-value' )
+    assert_equal( true, t2.tag_defined? )
+    assert_equal( 'some-value', t2.value )
+  end
+end
+

data/tests/tc_tag_no_value.rb

@@ -0,0 +1,46 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) )
+
+require 'test/unit'
+
+require 'cls-ruby/parser'
+require 'cls-ruby/tag_no_value'
+
+class TC_TagNoValue < Test::Unit::TestCase
+  def test_string_token
+    tag = ClsRuby::TagNoValue.new( :name => 'sample' )
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{sample "value"}', tag )
+    end
+  end
+
+  def test_nonspace_token
+    tag = ClsRuby::TagNoValue.new( :name => 'sample' )
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{sample value}', tag )
+    end
+  end
+
+  def test_no_entries
+    tag = ClsRuby::TagNoValue.new( :name => 'sample' )
+    assert_nothing_raised do
+      ClsRuby::parse_string( '   ', tag )
+    end
+    assert_equal( false, tag.tag_defined? )
+  end
+
+  def test_multiple_entries_no_once
+    tag = ClsRuby::TagNoValue.new( :name => 'sample' )
+    assert_nothing_raised do
+      ClsRuby::parse_string( '{sample} {sample}  {sample}', tag )
+    end
+    assert_equal( true, tag.tag_defined? )
+  end
+
+  def test_multiple_entries_once
+    tag = ClsRuby::TagNoValue.new( :name => 'sample', :once => true )
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{sample} {sample}  {sample}', tag )
+    end
+  end
+end
+

data/tests/tc_tag_scalar_int.rb

@@ -0,0 +1,83 @@
+$:.unshift( File.join( File.dirname( __FILE__ ), '../lib' ) ) 
+require 'test/unit'
+
+require 'cls-ruby/parser'
+require 'cls-ruby/tag_scalar'
+require 'cls-ruby/basic_scalars'
+
+class TC_TagScalarInt < Test::Unit::TestCase
+  def setup
+    @tag = ClsRuby::TagScalar.new :name => 'test',
+        :format => ClsRuby::SCALAR_INT,
+        :constraint => 1..1000
+  end 
+
+  def test_normal
+    assert_nothing_raised do
+      ClsRuby::parse_string '{test 234}', @tag
+    end
+
+    assert_equal( 234, @tag.value )
+  end
+
+  def test_fetch
+    assert_nothing_raised do
+      ClsRuby::parse_string '', @tag
+    end
+
+    assert_equal( false, @tag.tag_defined? )
+    assert_equal( nil, @tag.value )
+    assert_equal( 345, @tag.fetch( 345 ) )
+  end
+
+  def test_no_value
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{test}', @tag )
+    end
+  end
+
+  def test_two_tags
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{test 1} {test 2}', @tag )
+    end
+  end
+
+  def test_two_values
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{test 1 2}', @tag )
+    end
+  end
+
+  def test_string_as_value
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{test "1"}', @tag )
+    end
+  end
+
+  def test_reset
+    test_normal
+    @tag.tag_reset
+    test_normal
+  end
+
+  def test_out_of_range_min
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{test 0}', @tag )
+    end
+  end
+
+  def test_out_of_range_max
+    assert_raise( ClsRuby::ParsingErrorEx ) do
+      ClsRuby::parse_string( '{test 1001}', @tag )
+    end
+  end
+end
+
+class TC_AutoDefineTagIntScalar < Test::Unit::TestCase
+  def test_autodefine
+    t = ClsRuby::TagIntScalar.new( :name => 'n', :value => 1 )
+    assert_equal( true, t.tag_defined? )
+    assert_equal( 1, t.value )
+  end
+end
+