# Run this file as:
# 
#    % ruby test-rx.rb
#    Loaded suite test-rx
#    Started
#    .F.FFF......
#    Finished in 0.036449795 seconds.
#    
#      1) Failure:
#    test_alt_multiarg(TestRX) [test-rx.rb:118]:
#    <[1]> expected but was
#    <[]>.
#    
#      2) Failure:
#    test_cat3(TestRX) [test-rx.rb:162]:
#    <[3, 4, 4, 5, 4, 5, 5, 6]> expected but was
#    <[2, 3, 3, 4]>.
#    
#      3) Failure:
#    test_cat4(TestRX) [test-rx.rb:187]:
#    <[4]> expected but was
#    <[2]>.
#    
#      4) Failure:
#    test_cat_multiarg(TestRX) [test-rx.rb:134]:
#    <[4]> expected but was
#    <[2]>.
#    
#    12 tests, 37 assertions, 4 failures, 0 errors
#
# Modify try_cat and try_alt to fix these problems.

def try(re, str, pos)
  if re.respond_to? :to_str
    yield pos+1 if str[pos] == re
  else
    case re[0]
    when :empset
      # nothing to do
    when :empstr
      yield pos
    when :cat
      try_cat(re, str, pos) {|pos2| yield pos2 }
    when :cat3
      raise ArgumentError, "unexpected number of arguments: #{re.length-1}" if re.length-1 != 3
      try_cat(re, str, pos) {|pos2| yield pos2 }
    when :cat4
      raise ArgumentError, "unexpected number of arguments: #{re.length-1}" if re.length-1 != 4
      try_cat(re, str, pos) {|pos2| yield pos2 }
    when :alt
      try_alt(re, str, pos) {|pos2| yield pos2 }
    when :rep
      try_rep(re, str, pos) {|pos2| yield pos2 }
    else
      raise ArgumentError, "unexpected regular expression: #{re.inspect}"
    end
  end
end

def try_cat(re, str, pos) # Modify this function.
  try(re[1], str, pos) {|pos2|
    try(re[2], str, pos2) {|pos3|
      yield pos3
    }
  }
end

def try_alt(re, str, pos) # Modify this function.
  try(re[1], str, pos) {|pos2| yield pos2 }
  try(re[2], str, pos) {|pos2| yield pos2 }
end

def try_rep(re, str, pos)
  try(re[1], str, pos) {|pos2|
    try(re, str, pos2) {|pos3|
      yield pos3
    }
  }
  yield pos
end

if __FILE__ == $0
  require 'test/unit'

  def rx_ends(re, str, pos)
    a = []
    # str.split(//) returns an array which contains characters of str.
    try(re, str.split(//), pos) {|pos2| a << pos2 }
    a
  end

  class TestRX < Test::Unit::TestCase
    def test_empset
      assert_equal([], rx_ends([:empset], "", 0))
      assert_equal([], rx_ends([:empset], "cat", 0), "p.21")
    end

    def test_empstr
      assert_equal([0], rx_ends([:empstr], "", 0))
      assert_equal([0], rx_ends([:empstr], "cat", 0), "p.22")
    end

    def test_char
      assert_equal([1], rx_ends("a", "a", 0))
      assert_equal([1], rx_ends("c", "cat", 0), "p.20")
      assert_equal([], rx_ends("a", "cat", 0))
      assert_equal([], rx_ends("c", "cat", 1))
      assert_equal([2], rx_ends("a", "cat", 1))
    end

    def test_cat
      assert_equal([2], rx_ends([:cat, "a", "b"], "ab", 0))
      assert_equal([2], rx_ends([:cat, "c", "a"], "cat", 0), "p.23")
      assert_equal([2], rx_ends([:cat, [:alt, "a", "b"],
                                       [:alt, "a", "b"]], "abcd", 0))
      assert_equal([2,1,1,0], rx_ends([:cat, [:alt, "a", [:empstr]],
                                             [:alt, "a", [:empstr]]],
                                      "aaaa", 0), "p,35")
      assert_equal([2,3,3,4], rx_ends([:cat, [:alt, "a", [:cat, "a", "a"]],
                                             [:alt, "a", [:cat, "a", "a"]]], "aaaa", 0))

      assert_equal([1], rx_ends("a", "aaaaa", 0), "p.30")
      assert_equal([2], rx_ends([:cat, "a", "a"], "aaaaa", 0), "p.31")
      assert_equal([1,2], rx_ends([:alt, "a", [:cat, "a", "a"]], "aaaaa", 0), "p.32")
      assert_equal([2,3,3,4],
                   rx_ends([:cat, [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]]], "aaaaa", 0), "p.33")
    end

    def test_alt
      assert_equal([1], rx_ends([:alt, "a", "b"], "ab", 0))
      assert_equal([1], rx_ends([:alt, "c", "a"], "cat", 0), "p.25")
      assert_equal([2], rx_ends([:alt, "c", "a"], "cat", 1))
      assert_equal([], rx_ends([:alt, "c", "a"], "cat", 2))
      assert_equal([1,2], rx_ends([:alt, "a", [:cat, "a", "b"]], "ab", 0))
    end

    def test_rep
      assert_equal([3,2,1,0], rx_ends([:rep, "a"], "aaa", 0))
      assert_equal([1,0], rx_ends([:rep, "c"], "cat", 0), "p.27")
      assert_equal([2], rx_ends([:rep, "c"], "cat", 2))
      assert_equal([7,6,5], rx_ends([:rep, "p"], "pineapple", 5), "p.14")
      assert_equal([2], rx_ends([:rep, "p"], "pineapple", 2), "p.15")
      assert_equal([4,3,2,1,0], rx_ends([:rep, "a"], "aaaa", 0), "p.37")
      assert_equal([9,8,7,6,5,4,3,2,1,0], rx_ends([:rep, "a"], "aaaaaaaaa", 0), "p.17")
    end

    def test_alt_multiarg
      assert_equal([1], rx_ends([:alt, "a", "b", "c"], "a", 0))
      assert_equal([1], rx_ends([:alt, "a", "b", "c"], "b", 0))
      assert_equal([1], rx_ends([:alt, "a", "b", "c"], "c", 0))
      assert_equal([1,2], rx_ends([:alt, "a", [:cat, "a", "a"]], "aa", 0))

      assert_equal([1], rx_ends([:alt, "a", "b", "c", "d"], "a", 0))
      assert_equal([1], rx_ends([:alt, "a", "b", "c", "d"], "b", 0))
      assert_equal([1], rx_ends([:alt, "a", "b", "c", "d"], "c", 0))
      assert_equal([1], rx_ends([:alt, "a", "b", "c", "d"], "d", 0))
      assert_equal([1], rx_ends([:alt, "a"], "a", 0))
      assert_equal([], rx_ends([:alt], "a", 0))
      assert_equal([2,4,3,1], rx_ends([:alt, [:cat, "a", "a"],
                                       [:cat, "a", "a", "a", "a"],
                                       [:cat, "a", "a", "a"],
                                       "a",], "aaaaaaaa", 0))
    end

    def test_cat_multiarg
      assert_equal([4], rx_ends([:cat, "a", "b", "c", "d"], "abcd", 0))

      assert_equal([3,4,4,5,4,5,5,6],
                   rx_ends([:cat, [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]]], "aaaaaa", 0))
      assert_equal([3,4,4,5,4,5,5],
                   rx_ends([:cat, [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]]], "aaaaa", 0), "p.29, p.34")

      assert_equal([6], rx_ends([:cat, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "education", 3), "p.3")
      assert_equal([3], rx_ends([:cat, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "catch", 0))
      assert_equal([3], rx_ends([:cat, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "candle", 0))
      assert_equal([3], rx_ends([:cat, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "fatal", 0))
      assert_equal([3], rx_ends([:cat, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "fang", 0))

      assert_equal([7], rx_ends([:cat, "a", "p", "p"], "pineapple", 4), "p.12")
      assert_equal([], rx_ends([:cat, "a", "p", "p"], "pineapple", 3), "p.13")

    end

    def test_cat3
      assert_equal([3,4,4,5,4,5,5,6],
                   rx_ends([:cat3, [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]]], "aaaaaa", 0))
      assert_equal([3,4,4,5,4,5,5],
                   rx_ends([:cat3, [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]]], "aaaaa", 0), "p.29, p.34")

      assert_equal([6], rx_ends([:cat3, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "education", 3), "p.3")
      assert_equal([3], rx_ends([:cat3, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "catch", 0))
      assert_equal([3], rx_ends([:cat3, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "candle", 0))
      assert_equal([3], rx_ends([:cat3, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "fatal", 0))
      assert_equal([3], rx_ends([:cat3, [:alt, "c", "f"], "a", [:alt, "n", "t"]],
                                "fang", 0))

      assert_equal([7], rx_ends([:cat3, "a", "p", "p"], "pineapple", 4), "p.12")
      assert_equal([], rx_ends([:cat3, "a", "p", "p"], "pineapple", 3), "p.13")
    end

    def test_cat4
      assert_equal([4], rx_ends([:cat4, "a", "b", "c", "d"], "abcd", 0))
      assert_equal([4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8],
                   rx_ends([:cat4, [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]],
                                  [:alt, "a", [:cat, "a", "a"]]], "aaaaaaaa", 0))
    end
  end
end