regexp_parser 0.1.6 → 0.2.0

data/test/lexer/test_nesting.rb

@@ -4,91 +4,91 @@ class LexerNesting < Test::Unit::TestCase
 
   tests = {
     '(((b)))' => {
-      0     => [:group,       :capture,       '(',      0,  1, 0, 0],
-      1     => [:group,       :capture,       '(',      1,  2, 1, 0],
-      2     => [:group,       :capture,       '(',      2,  3, 2, 0],
-      3     => [:literal,     :literal,       'b',      3,  4, 3, 0],
-      4     => [:group,       :close,         ')',      4,  5, 2, 0],
-      5     => [:group,       :close,         ')',      5,  6, 1, 0],
-      6     => [:group,       :close,         ')',      6,  7, 0, 0],
+      0     => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
+      1     => [:group,       :capture,       '(',      1,  2, 1, 0, 0],
+      2     => [:group,       :capture,       '(',      2,  3, 2, 0, 0],
+      3     => [:literal,     :literal,       'b',      3,  4, 3, 0, 0],
+      4     => [:group,       :close,         ')',      4,  5, 2, 0, 0],
+      5     => [:group,       :close,         ')',      5,  6, 1, 0, 0],
+      6     => [:group,       :close,         ')',      6,  7, 0, 0, 0],
     },
 
     '(\((b)\))' => {
-      0     => [:group,       :capture,       '(',      0,  1, 0, 0],
-      1     => [:escape,      :group_open,    '\(',     1,  3, 1, 0],
-      2     => [:group,       :capture,       '(',      3,  4, 1, 0],
-      3     => [:literal,     :literal,       'b',      4,  5, 2, 0],
-      4     => [:group,       :close,         ')',      5,  6, 1, 0],
-      5     => [:escape,      :group_close,   '\)',     6,  8, 1, 0],
-      6     => [:group,       :close,         ')',      8,  9, 0, 0],
+      0     => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
+      1     => [:escape,      :group_open,    '\(',     1,  3, 1, 0, 0],
+      2     => [:group,       :capture,       '(',      3,  4, 1, 0, 0],
+      3     => [:literal,     :literal,       'b',      4,  5, 2, 0, 0],
+      4     => [:group,       :close,         ')',      5,  6, 1, 0, 0],
+      5     => [:escape,      :group_close,   '\)',     6,  8, 1, 0, 0],
+      6     => [:group,       :close,         ')',      8,  9, 0, 0, 0],
     },
 
     '(?>a(?>b(?>c)))' => {
-      0     => [:group,       :atomic,        '(?>',    0,  3, 0, 0],
-      2     => [:group,       :atomic,        '(?>',    4,  7, 1, 0],
-      4     => [:group,       :atomic,        '(?>',    8, 11, 2, 0],
-      6     => [:group,       :close,         ')',     12, 13, 2, 0],
-      7     => [:group,       :close,         ')',     13, 14, 1, 0],
-      8     => [:group,       :close,         ')',     14, 15, 0, 0],
+      0     => [:group,       :atomic,        '(?>',    0,  3, 0, 0, 0],
+      2     => [:group,       :atomic,        '(?>',    4,  7, 1, 0, 0],
+      4     => [:group,       :atomic,        '(?>',    8, 11, 2, 0, 0],
+      6     => [:group,       :close,         ')',     12, 13, 2, 0, 0],
+      7     => [:group,       :close,         ')',     13, 14, 1, 0, 0],
+      8     => [:group,       :close,         ')',     14, 15, 0, 0, 0],
     },
 
     '(?:a(?:b(?:c)))' => {
-      0     => [:group,       :passive,       '(?:',    0,  3, 0, 0],
-      2     => [:group,       :passive,       '(?:',    4,  7, 1, 0],
-      4     => [:group,       :passive,       '(?:',    8, 11, 2, 0],
-      6     => [:group,       :close,         ')',     12, 13, 2, 0],
-      7     => [:group,       :close,         ')',     13, 14, 1, 0],
-      8     => [:group,       :close,         ')',     14, 15, 0, 0],
+      0     => [:group,       :passive,       '(?:',    0,  3, 0, 0, 0],
+      2     => [:group,       :passive,       '(?:',    4,  7, 1, 0, 0],
+      4     => [:group,       :passive,       '(?:',    8, 11, 2, 0, 0],
+      6     => [:group,       :close,         ')',     12, 13, 2, 0, 0],
+      7     => [:group,       :close,         ')',     13, 14, 1, 0, 0],
+      8     => [:group,       :close,         ')',     14, 15, 0, 0, 0],
     },
 
     '(?=a(?!b(?<=c(?<!d))))' => {
-      0     => [:assertion,   :lookahead,     '(?=',    0,  3, 0, 0],
-      2     => [:assertion,   :nlookahead,    '(?!',    4,  7, 1, 0],
-      4     => [:assertion,   :lookbehind,    '(?<=',   8, 12, 2, 0],
-      6     => [:assertion,   :nlookbehind,   '(?<!',  13, 17, 3, 0],
-      8     => [:group,       :close,         ')',     18, 19, 3, 0],
-      9     => [:group,       :close,         ')',     19, 20, 2, 0],
-      10    => [:group,       :close,         ')',     20, 21, 1, 0],
-      11    => [:group,       :close,         ')',     21, 22, 0, 0],
+      0     => [:assertion,   :lookahead,     '(?=',    0,  3, 0, 0, 0],
+      2     => [:assertion,   :nlookahead,    '(?!',    4,  7, 1, 0, 0],
+      4     => [:assertion,   :lookbehind,    '(?<=',   8, 12, 2, 0, 0],
+      6     => [:assertion,   :nlookbehind,   '(?<!',  13, 17, 3, 0, 0],
+      8     => [:group,       :close,         ')',     18, 19, 3, 0, 0],
+      9     => [:group,       :close,         ')',     19, 20, 2, 0, 0],
+      10    => [:group,       :close,         ')',     20, 21, 1, 0, 0],
+      11    => [:group,       :close,         ')',     21, 22, 0, 0, 0],
     },
 
     '((?#a)b(?#c)d(?#e))' => {
-      0     => [:group,       :capture,       '(',      0,  1, 0, 0],
-      1     => [:group,       :comment,       '(?#a)',  1,  6, 1, 0],
-      3     => [:group,       :comment,       '(?#c)',  7, 12, 1, 0],
-      5     => [:group,       :comment,       '(?#e)', 13, 18, 1, 0],
-      6     => [:group,       :close,         ')',     18, 19, 0, 0],
+      0     => [:group,       :capture,       '(',      0,  1, 0, 0, 0],
+      1     => [:group,       :comment,       '(?#a)',  1,  6, 1, 0, 0],
+      3     => [:group,       :comment,       '(?#c)',  7, 12, 1, 0, 0],
+      5     => [:group,       :comment,       '(?#e)', 13, 18, 1, 0, 0],
+      6     => [:group,       :close,         ')',     18, 19, 0, 0, 0],
     },
 
     'a[b-e]f' => {
-      1     => [:set,         :open,          '[',      1,  2, 0, 0],
-      2     => [:set,         :range,         'b-e',    2,  5, 0, 1],
-      3     => [:set,         :close,         ']',      5,  6, 0, 0],
+      1     => [:set,         :open,          '[',      1,  2, 0, 0, 0],
+      2     => [:set,         :range,         'b-e',    2,  5, 0, 1, 0],
+      3     => [:set,         :close,         ']',      5,  6, 0, 0, 0],
     },
 
     '[a-w&&[^c-g]z]' => {
-      0     => [:set,         :open,          '[',      0,  1, 0, 0],
-      2     => [:set,         :intersection,  '&&',     4,  6, 0, 1],
-      3     => [:subset,      :open,          '[',      6,  7, 0, 1],
-      4     => [:subset,      :negate,        '^',      7,  8, 0, 2],
-      5     => [:subset,      :range,         'c-g',    8, 11, 0, 2],
-      6     => [:subset,      :close,         ']',     11, 12, 0, 1],
-      8     => [:set,         :close,         ']',     13, 14, 0, 0],
+      0     => [:set,         :open,          '[',      0,  1, 0, 0, 0],
+      2     => [:set,         :intersection,  '&&',     4,  6, 0, 1, 0],
+      3     => [:subset,      :open,          '[',      6,  7, 0, 1, 0],
+      4     => [:subset,      :negate,        '^',      7,  8, 0, 2, 0],
+      5     => [:subset,      :range,         'c-g',    8, 11, 0, 2, 0],
+      6     => [:subset,      :close,         ']',     11, 12, 0, 1, 0],
+      8     => [:set,         :close,         ']',     13, 14, 0, 0, 0],
     },
 
     '[a[b[c[d-g]]]]' => {
-      0     => [:set,         :open,          '[',      0,  1, 0, 0],
-      1     => [:set,         :member,        'a',      1,  2, 0, 1],
-      2     => [:subset,      :open,          '[',      2,  3, 0, 1],
-      3     => [:subset,      :member,        'b',      3,  4, 0, 2],
-      4     => [:subset,      :open,          '[',      4,  5, 0, 2],
-      5     => [:subset,      :member,        'c',      5,  6, 0, 3],
-      6     => [:subset,      :open,          '[',      6,  7, 0, 3],
-      7     => [:subset,      :range,         'd-g',    7, 10, 0, 4],
-      8     => [:subset,      :close,         ']',     10, 11, 0, 3],
-      9     => [:subset,      :close,         ']',     11, 12, 0, 2],
-     10     => [:subset,      :close,         ']',     12, 13, 0, 1],
-     11     => [:set,         :close,         ']',     13, 14, 0, 0],
+      0     => [:set,         :open,          '[',      0,  1, 0, 0, 0],
+      1     => [:set,         :member,        'a',      1,  2, 0, 1, 0],
+      2     => [:subset,      :open,          '[',      2,  3, 0, 1, 0],
+      3     => [:subset,      :member,        'b',      3,  4, 0, 2, 0],
+      4     => [:subset,      :open,          '[',      4,  5, 0, 2, 0],
+      5     => [:subset,      :member,        'c',      5,  6, 0, 3, 0],
+      6     => [:subset,      :open,          '[',      6,  7, 0, 3, 0],
+      7     => [:subset,      :range,         'd-g',    7, 10, 0, 4, 0],
+      8     => [:subset,      :close,         ']',     10, 11, 0, 3, 0],
+      9     => [:subset,      :close,         ']',     11, 12, 0, 2, 0],
+     10     => [:subset,      :close,         ']',     12, 13, 0, 1, 0],
+     11     => [:set,         :close,         ']',     13, 14, 0, 0, 0],
     },
   }
 
@@ -96,7 +96,7 @@ class LexerNesting < Test::Unit::TestCase
   tests.each do |pattern, checks|
     define_method "test_lex_nesting_#{count+=1}" do
 
-      tokens = RL.scan(pattern, 'ruby/1.9')
+      tokens = RL.lex(pattern, 'ruby/1.9')
       checks.each do |offset, token|
         assert_equal( token, tokens[offset].to_a )
       end

data/test/lexer/test_refcalls.rb

@@ -4,41 +4,39 @@ class LexerRefCalls < Test::Unit::TestCase
 
   tests = {
     # Group back-references, named, numbered, and relative
-    '(?<X>abc)\k<X>'  => [3, :backref, :name_ref,           '\k<X>',      9, 14, 0, 0],
-    "(?<X>abc)\\k'X'" => [3, :backref, :name_ref,           "\\k'X'",     9, 14, 0, 0],
+    '(?<X>abc)\k<X>'  => [3, :backref, :name_ref,           '\k<X>',      9, 14, 0, 0, 0],
+    "(?<X>abc)\\k'X'" => [3, :backref, :name_ref,           "\\k'X'",     9, 14, 0, 0, 0],
 
-    '(abc)\k<1>'      => [3, :backref, :number_ref,         '\k<1>',      5, 10, 0, 0],
-    "(abc)\\k'1'"     => [3, :backref, :number_ref,         "\\k'1'",     5, 10, 0, 0],
+    '(abc)\k<1>'      => [3, :backref, :number_ref,         '\k<1>',      5, 10, 0, 0, 0],
+    "(abc)\\k'1'"     => [3, :backref, :number_ref,         "\\k'1'",     5, 10, 0, 0, 0],
 
-    '(abc)\k<-1>'     => [3, :backref, :number_rel_ref,     '\k<-1>',     5, 11, 0, 0],
-    "(abc)\\k'-1'"    => [3, :backref, :number_rel_ref,     "\\k'-1'",    5, 11, 0, 0],
+    '(abc)\k<-1>'     => [3, :backref, :number_rel_ref,     '\k<-1>',     5, 11, 0, 0, 0],
+    "(abc)\\k'-1'"    => [3, :backref, :number_rel_ref,     "\\k'-1'",    5, 11, 0, 0, 0],
 
     # Sub-expression invocation, named, numbered, and relative
-    '(?<X>abc)\g<X>'  => [3, :backref, :name_call,          '\g<X>',      9, 14, 0, 0],
-    "(?<X>abc)\\g'X'" => [3, :backref, :name_call,          "\\g'X'",     9, 14, 0, 0],
+    '(?<X>abc)\g<X>'  => [3, :backref, :name_call,          '\g<X>',      9, 14, 0, 0, 0],
+    "(?<X>abc)\\g'X'" => [3, :backref, :name_call,          "\\g'X'",     9, 14, 0, 0, 0],
 
-    '(abc)\g<1>'      => [3, :backref, :number_call,        '\g<1>',      5, 10, 0, 0],
-    "(abc)\\g'1'"     => [3, :backref, :number_call,        "\\g'1'",     5, 10, 0, 0],
+    '(abc)\g<1>'      => [3, :backref, :number_call,        '\g<1>',      5, 10, 0, 0, 0],
+    "(abc)\\g'1'"     => [3, :backref, :number_call,        "\\g'1'",     5, 10, 0, 0, 0],
 
-    '(abc)\g<-1>'     => [3, :backref, :number_rel_call,    '\g<-1>',     5, 11, 0, 0],
-    "(abc)\\g'-1'"    => [3, :backref, :number_rel_call,    "\\g'-1'",    5, 11, 0, 0],
+    '(abc)\g<-1>'     => [3, :backref, :number_rel_call,    '\g<-1>',     5, 11, 0, 0, 0],
+    "(abc)\\g'-1'"    => [3, :backref, :number_rel_call,    "\\g'-1'",    5, 11, 0, 0, 0],
 
     # Group back-references, with nesting level
-    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_nest_ref,    '\k<X-0>',    9, 16, 0, 0],
-    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_nest_ref,    "\\k'X-0'",   9, 16, 0, 0],
+    '(?<X>abc)\k<X-0>'  => [3, :backref, :name_nest_ref,    '\k<X-0>',    9, 16, 0, 0, 0],
+    "(?<X>abc)\\k'X-0'" => [3, :backref, :name_nest_ref,    "\\k'X-0'",   9, 16, 0, 0, 0],
 
-    '(abc)\k<1-0>'      => [3, :backref, :number_nest_ref,  '\k<1-0>',    5, 12, 0, 0],
-    "(abc)\\k'1-0'"     => [3, :backref, :number_nest_ref,  "\\k'1-0'",   5, 12, 0, 0],
+    '(abc)\k<1-0>'      => [3, :backref, :number_nest_ref,  '\k<1-0>',    5, 12, 0, 0, 0],
+    "(abc)\\k'1-0'"     => [3, :backref, :number_nest_ref,  "\\k'1-0'",   5, 12, 0, 0, 0],
   }
 
   count = 0
   tests.each do |pattern, test|
     define_method "test_lexer_#{test[1]}_#{test[2]}_#{count+=1}" do
 
-      tokens = RL.scan(pattern, 'ruby/1.9')
-      assert_equal( test[1,7], tokens[test[0]].to_a)
-      assert_equal( test[3],   pattern[tokens[test[0]][3], tokens[test[0]][4]])
-
+      tokens = RL.lex(pattern, 'ruby/1.9')
+      assert_equal( test[1,8], tokens[test[0]].to_a)
     end
   end
 

data/test/parser/test_all.rb

@@ -1,18 +1,25 @@
 require File.expand_path("../../helpers", __FILE__)
 
 %w{
-  alternation anchors errors escapes groups properties
-  quantifiers refcalls sets
+  alternation anchors errors escapes free_space groups
+  properties quantifiers refcalls sets
 }.each do|tc|
   require File.expand_path("../test_#{tc}", __FILE__)
 end
 
+if RUBY_VERSION >= '2.0.0'
+  %w{conditionals keep}.each do|tc|
+    require File.expand_path("../test_#{tc}", __FILE__)
+  end
+end
+
 class TestParser < Test::Unit::TestCase
 
   def test_parse_returns_a_root_expression
     assert_instance_of( Regexp::Expression::Root, RP.parse('abc'))
   end
 
+
   def test_parse_root_contains_expressions
     root = RP.parse(/^a.c+[^one]{2,3}\b\d\\\C-C$/)
 
@@ -21,7 +28,7 @@ class TestParser < Test::Unit::TestCase
       "Not all nodes are instances of Regexp::Expression")
   end
 
-  # too much going on here, it's just for development
+
   def test_parse_node_types
     root = RP.parse('^(one){2,3}([^d\]efm-qz\,\-]*)(ghi)+$')
 
@@ -41,4 +48,12 @@ class TestParser < Test::Unit::TestCase
     assert_equal( true, root.expressions[3].quantified? )
   end
 
+  def test_parse_no_quantifier_target_raises_error
+    assert_raise( ArgumentError ) { RP.parse('?abc') }
+  end
+
+  def test_parse_sequence_no_quantifier_target_raises_error
+    assert_raise( ArgumentError ) { RP.parse('abc|?def') }
+  end
+
 end

data/test/parser/test_alternation.rb

@@ -2,9 +2,6 @@ require File.expand_path("../../helpers", __FILE__)
 
 class ParserAlternation < Test::Unit::TestCase
 
-  # TODO: these tests pass, but they show how hard and messy the tree is
-  # to navigate
-
   def setup
     @root = RP.parse('(ab??|cd*|ef+)*|(gh|ij|kl)?')
   end
@@ -17,8 +14,8 @@ class ParserAlternation < Test::Unit::TestCase
   def test_parse_alternation_alts
     alts = @root.expressions[0].alternatives
 
-    assert_equal( true,   alts[0].is_a?(Sequence) )
-    assert_equal( true,   alts[1].is_a?(Sequence) )
+    assert_equal( true,   alts[0].is_a?(Alternative) )
+    assert_equal( true,   alts[1].is_a?(Alternative) )
 
     assert_equal( true,   alts[0][0].is_a?(Group::Capture) )
     assert_equal( true,   alts[1][0].is_a?(Group::Capture) )
@@ -36,7 +33,7 @@ class ParserAlternation < Test::Unit::TestCase
     alts    = @root.expressions[0][0]
     nested  = alts.expressions[0][0][0]
 
-    assert_equal( true,   nested.is_a?(Sequence) )
+    assert_equal( true,   nested.is_a?(Alternative) )
 
     assert_equal( true,   nested.expressions[0].is_a?(Literal) )
     assert_equal( true,   nested.expressions[1].is_a?(Literal) )
@@ -56,10 +53,10 @@ class ParserAlternation < Test::Unit::TestCase
     alts = root.expressions[1][0].alternatives
 
     assert_equal( 4,  alts.length )
-    assert_equal( true,   alts[0].is_a?(Sequence) )
-    assert_equal( true,   alts[1].is_a?(Sequence) )
-    assert_equal( true,   alts[2].is_a?(Sequence) )
-    assert_equal( true,   alts[3].is_a?(Sequence) )
+    assert_equal( true,   alts[0].is_a?(Alternative) )
+    assert_equal( true,   alts[1].is_a?(Alternative) )
+    assert_equal( true,   alts[2].is_a?(Alternative) )
+    assert_equal( true,   alts[3].is_a?(Alternative) )
   end
 
   def test_parse_alternation_nested_grouped_alts
@@ -68,14 +65,14 @@ class ParserAlternation < Test::Unit::TestCase
     alts = root.expressions[1][0].alternatives
 
     assert_equal( 2,  alts.length )
-    assert_equal( true,   alts[0].is_a?(Sequence) )
-    assert_equal( true,   alts[1].is_a?(Sequence) )
+    assert_equal( true,   alts[0].is_a?(Alternative) )
+    assert_equal( true,   alts[1].is_a?(Alternative) )
 
     subalts = root.expressions[1][0][0][0][0].alternatives
 
     assert_equal( 2,  alts.length )
-    assert_equal( true,   subalts[0].is_a?(Sequence) )
-    assert_equal( true,   subalts[1].is_a?(Sequence) )
+    assert_equal( true,   subalts[0].is_a?(Alternative) )
+    assert_equal( true,   subalts[1].is_a?(Alternative) )
   end
 
   def test_parse_alternation_continues_after_nesting

data/test/parser/test_conditionals.rb

@@ -0,0 +1,148 @@
+require File.expand_path("../../helpers", __FILE__)
+
+class TestParserConditionals < Test::Unit::TestCase
+
+  def test_parse_conditional
+    regexp = /(?<A>a)(?(<A>)T|F)/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+    exp  = root.expressions[1]
+
+    assert( exp.is_a?( Conditional::Expression ),
+           "Expected Condition, but got #{exp.class.name}")
+
+    assert_equal( exp.type,   :conditional )
+    assert_equal( exp.token,  :open )
+    assert_equal( exp.text,   '(?' )
+  end
+
+
+  def test_parse_conditional_condition
+    regexp = /(?<A>a)(?(<A>)T|F)/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+    exp  = root[1].condition
+
+    assert( exp.is_a?( Conditional::Condition ),
+           "Expected Condition, but got #{exp.class.name}")
+
+    assert_equal( exp.type,   :conditional )
+    assert_equal( exp.token,  :condition )
+    assert_equal( exp.text,   '(<A>)' )
+  end
+
+
+  def test_parse_conditional_nested_groups
+    regexp = /((a)|(b)|((?(2)(c(d|e)+)?|(?(3)f|(?(4)(g|(h)(i)))))))/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+
+    assert_equal( regexp.source, root.to_s )
+
+    group = root.first
+    assert_equal( Group::Capture, group.class )
+
+    alt = group.first
+    assert_equal( Alternation, alt.class )
+    assert_equal( 3, alt.length )
+
+    assert_equal( true, alt.all? {|exp|
+      exp.first.is_a?(Group::Capture) }
+    )
+
+    subgroup    = alt[2].first
+    conditional = subgroup.first
+
+    assert_equal( Conditional::Expression, conditional.class )
+    assert_equal( 3, conditional.length )
+
+    assert_equal( Conditional::Condition,  conditional[0].class )
+    assert_equal( '(2)',                   conditional[0].text )
+
+    condition = conditional.condition
+    assert_equal( Conditional::Condition,  condition.class )
+    assert_equal( '(2)',                   condition.text )
+
+    branches = conditional.branches
+    assert_equal( 2,      branches.length )
+    assert_equal( Array,  branches.class )
+  end
+
+  def test_parse_conditional_nested
+    regexp = /(a(b(c)))(?(1)(?(2)d|(?(3)e|f))|(?(4)(?(5)g|h)))/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+
+    assert_equal( regexp.source, root.to_s )
+
+    { 1 => [2, root[1]],
+      2 => [2, root[1][1][0]],
+      3 => [2, root[1][1][0][2][0]],
+      4 => [1, root[1][2][0]],
+      5 => [2, root[1][2][0][1][0]],
+    }.each do |index, test|
+      branch_count, exp = test
+
+      assert_equal( Conditional::Expression, exp.class )
+      assert_equal( "(#{index})", exp.condition.text )
+      assert_equal( branch_count, exp.branches.length )
+    end
+  end
+
+
+  def test_parse_conditional_nested_alternation
+    regexp = /(a)(?(1)(b|c|d)|(e|f|g))(h)(?(2)(i|j|k)|(l|m|n))|o|p/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+
+    assert_equal( regexp.source, root.to_s )
+
+    assert_equal( Alternation, root.first.class )
+
+    [ [3, 'b|c|d', root[0][0][1][1][0][0]],
+      [3, 'e|f|g', root[0][0][1][2][0][0]],
+      [3, 'i|j|k', root[0][0][3][1][0][0]],
+      [3, 'l|m|n', root[0][0][3][2][0][0]],
+    ].each do |test|
+      alt_count, alt_text, exp = test
+
+      assert_equal( Alternation, exp.class )
+      assert_equal( alt_text,    exp.to_s )
+      assert_equal( alt_count,   exp.alternatives.length )
+    end
+  end
+
+
+  def test_parse_conditional_extra_separator
+    regexp = /(?<A>a)(?(<A>)T|)/
+
+    root = RP.parse(regexp, 'ruby/2.0')
+    branches = root[1].branches
+
+    assert_equal( 2, branches.length )
+
+    seq_1, seq_2 = branches
+
+    [seq_1, seq_2].each do |seq|
+      assert( seq.is_a?( Sequence ),
+             "Expected Condition, but got #{seq.class.name}")
+
+      assert_equal( :expression, seq.type )
+      assert_equal( :sequence,   seq.token )
+    end
+
+    assert_equal( 'T', seq_1.to_s )
+    assert_equal( '',  seq_2.to_s )
+  end
+
+
+  # For source (text) expressions only, ruby raises an error otherwise.
+  def test_parse_conditional_excessive_branches
+    regexp = '(?<A>a)(?(<A>)T|F|X)'
+
+    assert_raise( Conditional::TooManyBranches ) {
+      RP.parse(regexp, 'ruby/2.0')
+    }
+  end
+
+end