require 'test/minirunit'
test_check "Test Struct"

s = Struct.new("MyStruct", :x, :y)

test_equal(Struct::MyStruct, s)

s1 = s.new(11, 22)
test_equal(11, s1["x"])
test_equal(22, s1["y"])

s1 = s.new
test_equal(nil, s1.x)
test_equal(nil, s1.y)
s1.x = 10
s1.y = 20
test_equal(10, s1.x)
test_equal(20, s1.y)
test_equal(10, s1[0])
test_equal(20, s1[1])
test_equal(20, s1[-1])

test_equal(2, s1.length)
test_equal(2, s1.size)

test_equal([10, 20], s1.values)

test_exception(NameError) { s1["froboz"] }
test_exception(IndexError) { s1[10] }

s2 = s.new(1, 2)
test_equal(1, s2.x)
test_equal(2, s2.y)

test_exception(ArgumentError) { s.new(1,2,3,4,5,6,7) }
test_exception(ArgumentError) { Struct.new }
test_exception(NameError) { Struct.new('foo', 'bar') }

# Anonymous Struct
a = Struct.new(:x, :y)
a1 = a.new(5, 7)
test_equal(5, a1.x)

# Struct::Tms
tms = Struct::Tms.new(0, 0, 0, 0)
test_ok(tms != nil)

# Struct creation with a block
a = Struct.new(:foo, :bar) {
  def hello
    "hello"
  end
}

test_equal("hello", a.new(0, 0).hello)

# Redefining a named struct should produce a warning, but it should be a new class
P1 = Struct.new("Post", :foo)
P1.class_eval do
  def bar
    true
  end
end
P2 = Struct.new("Post", :foo)

test_exception {
  P2.new.bar
}

MyStruct = Struct.new("MyStruct", :a, :b)
class MySubStruct < MyStruct
  def initialize(v, *args) super(*args); @v = v; end 
end

b = MySubStruct.new(1, 2)
inspect1 = b.inspect
b.instance_eval {"EH"}
# Instance_eval creates a metaclass and our inspect should not print that new metaclass out
test_equal(inspect1, b.inspect)
c = MySubStruct.new(1, 2)

class << b
  def foo
  end
end

# Even though they have different metaclasses they are still equal in the eyes of Ruby
test_equal(b, c)

c = Struct.new(:a)
s1 = c.new(1)
s2 = c.new(1)
test_ok(true, s1.eql?(s2))
test_equal(s1.hash, s2.hash)

test_no_exception { Struct.new(:icandup).new(1).dup }