require 'runit/cui/testrunner'
require 'runit/testcase'

# A unit test suite for public, protected, private, and secret instance
# methods.
#
# TODO: Write tests for class methods.
#

class Foo
  include RUNIT::Assert
public
  def public_foo
    return :foo
  end

protected
  def protected_foo
    return :foo
  end

private
  def private_foo
    return :foo
  end

secret
  def secret_foo
    return :foo
  end

public
  def public_self_test
    self.public_foo
  end

  def protected_self_test
    self.protected_foo
  end

  def private_self_test
    assert_exception(NoMethodError) do
      self.private_foo
    end
  end

  def secret_self_test
    assert_exception(NoMethodError) do
      self.secret_foo
    end
  end

  def public_test
    public_foo
  end

  def protected_test
    protected_foo
  end

  def private_test
    private_foo
  end

  def secret_test
    secret_foo
  end
end

class Bar < Foo
  def bar_public_self_test
    self.public_foo
  end

  def bar_protected_self_test
    self.protected_foo
  end

  def bar_private_self_test
    assert_exception(NoMethodError) do
      self.private_foo
    end
  end

  def bar_secret_self_test
    assert_exception(NoMethodError) do
      self.secret_foo
    end
  end

  def bar_public_test
    public_foo
  end

  def bar_protected_test
    protected_foo
  end

  def bar_private_test
    private_foo
  end

  def bar_secret_test
    assert_exception(NoMethodError) do
      secret_foo
    end
  end
end

class SafeMethodTest < RUNIT::TestCase
  def test_public_access
    f = Foo.new
    
    f.public_foo();
    
    assert_exception(NoMethodError) do
      f.protected_foo()
    end
    
    assert_exception(NoMethodError) do
      f.private_foo()
    end
    
    assert_exception(NoMethodError) do
      f.secret_foo()
    end
  end

  def test_same_class_access
    f = Foo.new
    f.public_methods.each do |m|
      if m =~ /_test/ then
        f.__send__(m)
      end
    end
  end
  
  def test_subclass_access
    b = Bar.new
    b.public_methods.each do |m|
      if m =~ /_test/ then
        b.__send__(m)
      end
    end
  end

  def test_instance_methods
    foo_pub_im = Foo.public_instance_methods
    foo_prot_im = Foo.protected_instance_methods
    foo_priv_im = Foo.private_instance_methods
    foo_secr_im = Foo.secret_instance_methods
    assert_not_nil foo_pub_im.index("public_foo")
    assert_not_nil foo_prot_im.index("protected_foo")
    assert_not_nil foo_secr_im.index("secret_foo")
    assert_nil foo_secr_im.index("public_foo")
  end

  def test_subclass_instance_methods
    bar_pub_im = Bar.public_instance_methods
    bar_prot_im = Bar.protected_instance_methods
    bar_priv_im = Bar.private_instance_methods
    bar_secr_im = Bar.secret_instance_methods
    assert_nil bar_pub_im.index("public_foo")
    assert_nil bar_prot_im.index("protected_foo")
    assert_nil bar_secr_im.index("secret_foo")
    assert_nil bar_secr_im.index("public_foo")
  end

  def test_methods
    f = Foo.new
    foo_pub = f.public_methods
    foo_prot = f.protected_methods
    foo_priv = f.private_methods
    foo_secr = f.secret_methods
    assert_not_nil foo_pub.index("public_foo")
    assert_not_nil foo_prot.index("protected_foo")
    assert_not_nil foo_secr.index("secret_foo")
    assert_nil foo_secr.index("public_foo")
  end

  def test_subclass_methods
    b = Bar.new
    bar_pub = b.public_methods
    bar_prot = b.protected_methods
    bar_priv = b.private_methods
    bar_secr = b.secret_methods
    assert_not_nil bar_pub.index("public_foo")
    assert_not_nil bar_prot.index("protected_foo")
    assert_not_nil bar_secr.index("secret_foo")
    assert_nil bar_secr.index("public_foo")
  end
end

RUNIT::CUI::TestRunner.run(SafeMethodTest.suite)