require File.expand_path("../../helpers", __FILE__)

class ExpressionClone < Test::Unit::TestCase

  def test_expression_clone_base
    root = RP.parse(/^(?i:a)b+$/i)
    copy = root.clone

    assert_not_equal(copy.object_id, root.object_id)

    # The text content is equal but the objects are not.
    assert_equal(copy.text, root.text)
    assert_not_equal(copy.text.object_id, root.text.object_id)

    root_1 = root.expressions[1]
    copy_1 = copy.expressions[1]

    # The options hash contents are equal but the objects are not.
    assert_equal(copy_1.options, root_1.options)
    assert_not_equal(copy_1.options.object_id,
                     root_1.options.object_id)

    root_2 = root.expressions[2]
    copy_2 = copy.expressions[2]

    assert( root_2.quantified? )
    assert( copy_2.quantified? )

    # The quantifier contents are equal but the objects are not.
    assert_equal(copy_2.quantifier.text, root_2.quantifier.text)

    assert_not_equal(copy_2.quantifier.text.object_id,
                     root_2.quantifier.text.object_id)

    assert_not_equal(copy_2.quantifier.object_id,
                     root_2.quantifier.object_id)
  end

  def test_expression_clone_subexpression
    root = RP.parse(/^a(b([cde])f)g$/)
    copy = root.clone

    assert( root.respond_to?(:expressions) )
    assert( copy.respond_to?(:expressions) )

    # The expressions arrays are not equal.
    assert_not_equal(copy.expressions.object_id,
                     root.expressions.object_id)

    # The expressions in the arrays are not equal.
    copy.expressions.each_with_index do |e, ei|
      assert_not_equal(e.object_id,
                       root.expressions[ei].object_id)
    end

    # The expressions in nested expressions are not equal.
    copy.expressions[2].each_with_index do |e, ei|
      assert_not_equal(e.object_id,
                       root.expressions[2][ei].object_id)
    end
  end

  # ruby 1.8 does not implement named groups
  def test_expression_clone_named_group
    root = RP.parse('^(?<somename>a)+bc$')
    copy = root.clone

    root_1 = root.expressions[1]
    copy_1 = copy.expressions[1]

    # The names are equal but their objects are not.
    assert_equal(copy_1.name, root_1.name)
    assert_not_equal(copy_1.name.object_id,
                     root_1.name.object_id)

    # Verify super: text objects should be different.
    assert_equal(copy_1.text, root_1.text)

    # Verify super: expressions arrays are not equal.
    assert_not_equal(copy_1.expressions.object_id,
                     root_1.expressions.object_id)

    # Verify super: expressions in the arrays are not equal.
    copy_1.expressions.each_with_index do |e, ei|
      assert_not_equal(e.object_id,
                       root_1.expressions[ei].object_id)
    end
  end

  def test_expression_clone_set
    root = RP.parse(/^a(b([cde])f)g$/)
    copy = root.clone

    root_2_1 = root.expressions[2][1]

    copy.expressions[2][1].each_with_index do |e, ei|
      assert( e.respond_to?(:members) )

      # The members arrays are not equal.
      assert_not_equal( e.members.object_id, root_2_1[ei].members.object_id )

      # The members in the arrays are not equal.
      e.members.each_with_index do |m, mi|
        assert_not_equal( m.object_id, root_2_1[ei].members[mi].object_id )
      end
    end
  end

  def test_expression_clone_subset
    # Explicitly set syntax to ruby 1.9 because 1.8 does not
    # implement subsets.
    root = RP.parse('^a(b([c[def]g])h)i$', 'ruby/1.9')
    copy = root.clone

    root_set    = root.expressions[2][1][0]
    copy_set    = copy.expressions[2][1][0]

    root_subset = root_set.members[1]
    copy_subset = copy_set.members[1]

    # Sanity checks
    assert( root_set.respond_to?(:members) )
    assert( copy_set.respond_to?(:members) )

    assert( root_subset.respond_to?(:members) )
    assert( copy_subset.respond_to?(:members) )

    # The sets are not equal
    assert_not_equal(copy_set.object_id, root_set.object_id)

    # The subsets are not equal
    assert_not_equal(copy_subset.object_id, root_subset.object_id)

    # The subsets' members arrays are not equal.
    assert_not_equal( copy_subset.members.object_id,
                      root_subset.members.object_id )

    # The subsets' members are not equal
    copy_subset.members.each_with_index do |m, mi|
      assert_not_equal(m.object_id, root_subset.members[mi].object_id)
    end
  end

end