require 'test/unit'
require 'sloop'

class TestSloopCore < Test::Unit::TestCase
  def test_010_create_new_sloop
    s = Sloop::Object.new
    assert_kind_of Sloop::Object, s

    s = sloop
    assert_kind_of Sloop::Object, s

    s = sloop { }
    assert_kind_of Sloop::Object, s
  end

  def test_020_slot_setting
    s = sloop
    assert s._slots.has_key?(:_parent)

    s.foo = 42
    assert_equal 42, s.foo
    assert_equal 42, s._slots[:foo]

    s.foo = "bar"
    assert_equal "bar", s.foo
    assert_equal "bar", s._slots[:foo]
    
    assert_equal [:_parent, :foo], s._slots.keys

    assert_raise ArgumentError do
      s.__send__(:foo=, 42, "bar")
    end
  end

  def test_030_define_methods
    s = sloop

    assert_raise NoMethodError do
      s.double
    end

    s.def :double do |x|
      x * 2
    end

    assert_kind_of Sloop::Method, s._slots[:double]
    assert_equal 10, s.double(5)
    assert_equal 144, s.double(72)

    tc = self
    s = sloop {
      tc.assert_raise NoMethodError do
        double
      end

      self.def :double do |x|
        x * 2
      end
    }

    assert_kind_of Sloop::Method, s._slots[:double]
    assert_equal 10, s.double(5)
    assert_equal 144, s.double(72)
  end

  def test_035_define_shortcuts
    s = sloop {
      def_double { |x| x * 2}
      def_pi 3.14
    }

    assert_kind_of Sloop::Method, s._slots[:double]
    assert_equal 10, s.double(5)
    assert_equal 144, s.double(72)
    assert_equal 3.14, s.pi

    assert_raise ArgumentError do
      s.def_wrong 1, 2, 3
    end
  end

  def test_040_inter_object_communication
    a = sloop {
      def_two 2
      def_double { |x| x * two }
      def_pi 3.14
    }
    b = sloop {
      def_radius { |r|
        a.double(r) * a.pi
      }
    }

    assert_in_delta  31.4, 0.0001, b.radius(5)
    assert_in_delta 125.6, 0.0001, b.radius(20)
  end

  def test_050_single_inheritance
    parent = sloop {
      def_foo { "root" }
      def_bar { "root" }
      def_baz { "root" }
    }
    child = sloop {
      self._parent = parent
      def_foo { "child" }
    }
    grandchild = sloop {
      self._parent = child
      def_bar { "grandchild" }
    }

    assert_equal "root", parent.foo
    assert_equal "root", parent.bar
    assert_equal "root", parent.baz

    assert_equal "child", child.foo
    assert_equal "root", child.bar
    assert_equal "root", child.baz

    assert_equal "child", grandchild.foo
    assert_equal "grandchild", grandchild.bar
    assert_equal "root", grandchild.baz
  end

  def test_051_inheritance_shortcut
    parent = sloop {
      def_foo { "root" }
      def_bar { "root" }
      def_baz { "root" }
    }
    child = sloop(parent) {
      def_foo { "child" }
    }
    grandchild = sloop(child) {
      def_bar { "grandchild" }
    }
    assert_equal "child", child.foo
    assert_equal "root", child.bar
    assert_equal "root", child.baz

    assert_equal "child", grandchild.foo
    assert_equal "grandchild", grandchild.bar
    assert_equal "root", grandchild.baz
  end

  def test_055_dynamic_inheritance
    parent = sloop {
      def_foo { "root" }
      def_bar { "root" }
      def_baz { "root" }
    }
    child = sloop(parent) {
      def_foo { "child" }
    }
    grandchild = sloop(child) {
      def_bar { "grandchild" }
    }

    assert_equal "child", grandchild.foo
    assert_equal "grandchild", grandchild.bar
    assert_equal "root", grandchild.baz

    grandchild._parent = parent

    assert_equal "root", grandchild.foo
    assert_equal "grandchild", grandchild.bar
    assert_equal "root", grandchild.baz
  end

  def test_060_clone
    adder = sloop {
      self.a = 0
      self.b = 0
      def_sum { a + b }
    }

    x = adder.clone
    x.a = 5
    x.b = 3

    y = adder.clone
    y.a = 1
    y.b = 4

    assert_equal 0, adder.a
    assert_equal 0, adder.b
    assert_equal 0, adder.sum

    assert_equal 5, x.a
    assert_equal 3, x.b
    assert_equal 8, x.sum

    assert_equal 1, y.a
    assert_equal 4, y.b
    assert_equal 5, y.sum
  end

  def test_070_multiple_inheritance
    parent = sloop
    child = sloop {
      self._parent = parent
      def_foo { "child 1" }
    }
    child2 = sloop {
      self._parent = parent
      def_foo { "child 2" }
      def_bar { "child 2" }
    }
    grandchild = sloop {
      self._parent = [child, child2]
    }

    assert_equal "child 1", grandchild.foo
    assert_equal "child 2", grandchild.bar

    grandchild = sloop {
      self._parent = [child2, child]
    }

    assert_equal "child 2", grandchild.foo
    assert_equal "child 2", grandchild.bar

    assert_raise NoMethodError do
      grandchild.nothere
    end
  end

  def test_080_conditional_inheritance
    wrap = sloop {
      self.x = 0
      def_inspect {
        "#(wrapper for #{x.inspect})"
      }
    }

    evenwrap = sloop(wrap) {
      condition {
        x.kind_of?(Integer) && x%2 == 0
      }
      def_inspect {
        "#(wrapper for the even number #{x})"
      }
    }

    oddwrap = sloop(evenwrap) {
      condition {
        x.kind_of?(Integer) && x%2 == 1
      }
      def_inspect {
        "#(wrapper for the odd number #{x})"
      }
    }

    intwrap = sloop(oddwrap) {
    }

    a = intwrap.clone
    a.x = 20
    b = intwrap.clone
    b.x = 23
    c = intwrap.clone
    c.x = "foo"

    assert_equal 20, a.x
    assert_equal "#(wrapper for the even number 20)", a.inspect
    assert_equal 23, b.x
    assert_equal "#(wrapper for the odd number 23)", b.inspect
    assert_equal "foo", c.x
    assert_equal '#(wrapper for "foo")', c.inspect
  end
end

class TestSloopStdlib < Test::Unit::TestCase
  def test_010_root_object
    s = sloop
    assert_equal Sloop::Root, s._parent
  end

  def test_015_basic_inspect
    s = sloop

    assert_equal "#(the root object)", Sloop::Root.inspect
    assert_equal "#(an object)", s.inspect
  end

  def test_020_inheritance
    r = sloop {
      def_foo { "r" }
    }

    s = sloop(r) {
      def_foo { "s" }
    }

    t = sloop(r) {
      inherit s
    }

    assert_equal "s", t.foo
  end

  def test_021_mixin
    r = sloop {
      def_foo { "r" }
    }

    s = sloop(r) {
      def_foo { "s" }
    }

    t = sloop(r) {
      mixin s
    }

    assert_equal "r", t.foo
  end
end