enclave 0.1.0

data/ext/enclave/mruby/test/t/class.rb

@@ -0,0 +1,505 @@
+##
+# Class ISO Test
+
+assert('Class', '15.2.3') do
+  assert_equal(Class, Class.class)
+end
+
+assert('Class#initialize', '15.2.3.3.1') do
+  c = Class.new do
+    def test
+      :test
+    end
+  end.new
+
+  assert_equal(c.test, :test)
+end
+
+assert('Class#initialize_copy', '15.2.3.3.2') do
+  class TestClass
+    attr_accessor :n
+    def initialize(n)
+      @n = n
+    end
+    def initialize_copy(obj)
+      @n = n
+    end
+  end
+
+  c1 = TestClass.new('Foo')
+  c2 = c1.dup
+  c3 = TestClass.new('Bar')
+
+  assert_equal(c1.n, c2.n)
+  assert_not_equal(c1.n, c3.n)
+end
+
+assert('Class#new', '15.2.3.3.3') do
+  assert_raise(TypeError, 'Singleton should raise TypeError') do
+    (class <<"a"; self; end).new
+  end
+
+  class TestClass
+    def initialize(args, &block)
+      @result = if not args.nil? and block.nil?
+        # only arguments
+        :only_args
+      elsif not args.nil? and not block.nil?
+        # args and block is given
+        :args_and_block
+      else
+        # this should never happen
+        :broken
+      end
+    end
+
+    def result; @result; end
+  end
+
+  assert_equal(:only_args, TestClass.new(:arg).result)
+  # with block doesn't work yet
+end
+
+assert('Class#superclass', '15.2.3.3.4') do
+  class SubClass < String; end
+  assert_equal(String, SubClass.superclass)
+end
+
+# Not ISO specified
+
+assert('Class 1') do
+  class C1; end
+  assert_equal(Class, C1.class)
+end
+
+assert('Class 2') do
+  class C2; end
+  assert_equal(C2, C2.new.class)
+end
+
+assert('Class 3') do
+  class C3; end
+  assert_equal(Class, C3.new.class.class)
+end
+
+assert('Class 4') do
+  class C4_A; end
+  class C4 < C4_A; end
+  assert_equal(Class, C4.class)
+end
+
+assert('Class 5') do
+  class C5_A; end
+  class C5 < C5_A; end
+  assert_equal(C5, C5.new.class)
+end
+
+assert('Class 6') do
+  class C6_A; end
+  class C6 < C6_A; end
+  assert_equal(Class, C6.new.class.class)
+end
+
+assert('Class 7') do
+  class C7_A; end
+  class C7_B; end
+
+  class C7 < C7_A; end
+
+  assert_raise(TypeError) do
+    # Different superclass.
+    class C7 < C7_B; end
+  end
+end
+
+assert('Class 8') do
+  class C8_A; end
+
+  class C8; end  # superclass is Object
+
+  assert_raise(TypeError) do
+    # Different superclass.
+    class C8 < C8_A; end
+  end
+end
+
+assert('Class 9') do
+  Class9Const = "a"
+
+  assert_raise(TypeError) do
+    class Class9Const; end
+  end
+end
+
+assert('Class Module 1') do
+  module M; end
+  assert_equal(Module, M.class)
+end
+
+assert('Class Module 2') do
+  module M; end
+  class C; include M; end
+  assert_equal(C, C.new.class)
+end
+
+# nested class
+assert('Class Nested 1') do
+  class A; end
+  class A::B; end
+  assert_equal(A::B, A::B)
+end
+
+assert('Class Nested 2') do
+  class A; end
+  class A::B; end
+  assert_equal(A::B, A::B.new.class)
+end
+
+assert('Class Nested 3') do
+  class A; end
+  class A::B; end
+  assert_equal(Class, A::B.new.class.class)
+end
+
+assert('Class Nested 4') do
+  class A; end
+  class A::B; end
+  class A::B::C; end
+  assert_equal(A::B::C, A::B::C)
+end
+
+assert('Class Nested 5') do
+  class A; end
+  class A::B; end
+  class A::B::C; end
+  assert_equal(Class, A::B::C.class)
+end
+
+assert('Class Nested 6') do
+  class A; end
+  class A::B; end
+  class A::B::C; end
+  assert_equal(A::B::C, A::B::C.new.class)
+end
+
+assert('Class Nested 7') do
+  class A; end
+  class A::B; end
+  class A::B2 < A::B; end
+  assert_equal(A::B2, A::B2)
+end
+
+assert('Class Nested 8') do
+  class A; end
+  class A::B; end
+  class A::B2 < A::B; end
+  assert_equal(Class, A::B2.class)
+end
+
+assert('Class Colon 1') do
+  class A; end
+  A::C = 1
+  assert_equal(1, A::C)
+end
+
+assert('Class Colon 2') do
+  class A; class ::C; end end
+  assert_equal(C, C)
+end
+
+assert('Class Colon 3') do
+  class A; class ::C; end end
+  assert_equal(Class, C.class)
+end
+
+assert('Class Dup 1') do
+  class C; end
+  assert_equal(Class, C.dup.class)
+end
+
+assert('Class Dup 2') do
+  module M; end
+  assert_equal(Module, M.dup.class)
+end
+
+assert('Class.new') do
+  assert_equal(Class, Class.new.class)
+  a = []
+  klass = Class.new do |c|
+    a << c
+  end
+  assert_equal([klass], a)
+end
+
+assert('class to return the last value') do
+  m = class C; :m end
+  assert_equal(m, :m)
+end
+
+assert('class to return nil if body is empty') do
+  assert_nil(class C end)
+  assert_nil(class << self; end)
+end
+
+assert('raise when superclass is not a class') do
+  module FirstModule; end
+  assert_raise(TypeError, 'should raise TypeError') do
+    class FirstClass < FirstModule; end
+  end
+
+  class SecondClass; end
+  assert_raise(TypeError, 'should raise TypeError') do
+    class SecondClass < false; end
+  end
+
+  class ThirdClass; end
+  assert_raise(TypeError, 'should raise TypeError') do
+    class ThirdClass < ThirdClass; end
+  end
+end
+
+assert('Class#inherited') do
+  class Foo
+    @@subclass_name = nil
+    def self.inherited(subclass)
+      @@subclass_name = subclass
+    end
+    def self.subclass_name
+      @@subclass_name
+    end
+  end
+
+  assert_equal(nil, Foo.subclass_name)
+
+  class Bar < Foo
+  end
+
+  assert_equal(Bar, Foo.subclass_name)
+
+  class Baz < Bar
+  end
+
+  assert_equal(Baz, Foo.subclass_name)
+end
+
+assert('singleton tests') do
+  module FooMod
+    def run_foo_mod
+      100
+    end
+  end
+
+  bar = String.new
+
+  baz = class << bar
+    extend FooMod
+    def self.run_baz
+      200
+    end
+  end
+
+  assert_equal :run_baz, baz
+
+  assert_raise(NoMethodError, 'should raise NoMethodError') do
+    bar.run_foo_mod
+  end
+  assert_raise(NoMethodError, 'should raise NoMethodError') do
+    bar.run_baz
+  end
+
+  baz = class << bar
+    extend FooMod
+    def self.run_baz
+      300
+    end
+    self
+  end
+
+  assert_true baz.respond_to? :run_baz
+  assert_true baz.respond_to? :run_foo_mod
+  assert_equal 100, baz.run_foo_mod
+  assert_equal 300, baz.run_baz
+
+  assert_raise(NoMethodError, 'should raise NoMethodError') do
+    bar.run_foo_mod
+  end
+  assert_raise(NoMethodError, 'should raise NoMethodError') do
+    bar.run_baz
+  end
+
+  fv = false
+  class << fv
+    def self.run_false
+      5
+    end
+  end
+
+  nv = nil
+  class << nv
+    def self.run_nil
+      6
+    end
+  end
+
+  tv = true
+  class << tv
+    def self.run_nil
+      7
+    end
+  end
+
+  assert_raise(TypeError, 'should raise TypeError') do
+    num = 1.0
+    class << num
+      def self.run_nil
+        7
+      end
+    end
+  end if Object.const_defined?(:Float)
+
+  o = Object.new
+  sc = class << o; self end
+  o.freeze
+  assert_predicate(sc, :frozen?)
+
+  assert_predicate(class << Object.new.freeze; self end, :frozen?)
+end
+
+assert('clone Class') do
+  class Foo
+    def func
+      true
+    end
+  end
+
+  assert_true(Foo.clone.new.func)
+end
+
+assert('class definition in singleton class') do
+  class AClassS
+    class << self
+      class BClass
+      end
+
+      def iclass
+        BClass
+      end
+    end
+  end
+  assert_equal(Class, AClassS.iclass.class)
+end
+
+assert('class variable and class << self style class method') do
+  class ClassVariableTest
+    @@class_variable = "value"
+    class << self
+      def class_variable
+        @@class_variable
+      end
+    end
+  end
+
+  assert_equal("value", ClassVariableTest.class_variable)
+end
+
+assert('class variable definition in singleton_class') do
+  class ClassVariableDefinitionInSingletonTest
+    class << self
+      @@class_variable = "value"
+    end
+    def class_variable
+      @@class_variable
+    end
+  end
+
+  assert_equal("value", ClassVariableDefinitionInSingletonTest.new.class_variable)
+end
+
+assert('class variable in module and class << self style class method') do
+  module ClassVariableInModuleTest
+    @@class_variable = "value"
+    class << self
+      def class_variable
+        @@class_variable
+      end
+    end
+  end
+
+  assert_equal("value", ClassVariableInModuleTest.class_variable)
+end
+
+assert('child class/module defined in singleton class get parent constant') do
+  actual = module GetParentConstantTest
+            EXPECT = "value"
+            class << self
+              class CHILD
+                class << self
+                    EXPECT
+                end
+              end
+            end
+          end
+  assert_equal("value", actual)
+end
+
+assert('overriding class variable with a module (#3235)') do
+  module ModuleWithCVar
+    @@class_variable = 1
+  end
+  class CVarOverrideTest
+    @@class_variable = 2
+    include ModuleWithCVar
+
+    assert_equal(1, @@class_variable)
+  end
+end
+
+assert('class variable for frozen class/module') do
+  module CVarForFrozenModule
+    freeze
+    assert_raise(FrozenError) { @@cv = 1 }
+  end
+
+  class CVarForFrozenClassA
+    @@a = nil
+    freeze
+  end
+  class CVarForFrozenClassB < CVarForFrozenClassA
+    def a=(v)
+      @@a = v
+    end
+  end
+  b = CVarForFrozenClassB.new
+  assert_raise(FrozenError) { b.a = 1 }
+end
+
+assert('class with non-class/module outer raises TypeError') do
+  assert_raise(TypeError) { class 0::C1; end }
+  assert_raise(TypeError) { class []::C2; end }
+end
+
+assert('module with extended callback') do
+  module FooWithExtended
+    @@extended = []
+
+    def self.extended(base)
+      @@extended << base
+    end
+
+    def self.extended_classes
+      @@extended
+    end
+
+    def answer
+      42
+    end
+  end
+
+  class BarBeingExtended
+    extend FooWithExtended
+  end
+
+  assert_equal [BarBeingExtended], FooWithExtended.extended_classes
+  assert_true BarBeingExtended.respond_to?(:answer)
+  assert_equal 42, BarBeingExtended.answer
+end

data/ext/enclave/mruby/test/t/codegen.rb

@@ -0,0 +1,196 @@
+##
+# Codegen tests
+
+assert('peephole optimization does not eliminate move whose result is reused') do
+  assert_raise LocalJumpError do
+    def method
+      yield
+    end
+    method(&a &&= 0)
+  end
+end
+
+assert('empty condition in ternary expression parses correctly') do
+  assert_equal(() ? 1 : 2, 2)
+end
+
+assert('method call with exactly 127 arguments') do
+  def args_to_ary(*args)
+    args
+  end
+
+  assert_equal [0]*127, args_to_ary(
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, \
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, \
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, \
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, \
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, \
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+  )
+end
+
+assert('nested empty heredoc') do
+  _, a = nil, <<B
+#{<<A}
+A
+B
+  assert_equal "\n", a
+end
+
+assert('splat in case splat') do
+  a = *case
+    when 0
+      * = 1
+  end
+
+  assert_equal [1], a
+end
+
+assert('undef with 127 or more arguments') do
+  assert_raise NameError do
+    undef
+      a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,
+      a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,
+      a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,
+      a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a
+  end
+end
+
+assert('break in normal loop with 127 arguments') do
+  assert_equal 127,
+    1.times{
+      break 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+    }.size
+end
+
+assert('negate literal register alignment') do
+  a = *case
+  when 0
+    -0.0
+    2
+  end
+
+  assert_equal [2], a
+end
+
+assert('register window of calls (#3783)') do
+  # NODE_FOR
+  assert_nothing_raised do
+    for i in []; end
+  end
+
+  # NODE_SYMBOLS
+  assert_nothing_raised do
+    %i(sym)
+  end
+
+  # NODE_SCALL
+  assert_nothing_raised do
+    Object.new&.__id__
+  end
+
+  # NODE_RESCUE with splat
+  assert_nothing_raised do
+    begin
+      raise
+    rescue *[Exception]
+    end
+  end
+
+  # NODE_CASE
+  assert_nothing_raised do
+    case 1
+    when nil
+    end
+  end
+
+  # NODE_CASE with splat
+  assert_nothing_raised do
+    case 1
+    when *nil
+    end
+  end
+
+  # NODE_HASH
+  assert_nothing_raised do
+    {}.merge(
+        0=>0,     1=>1,     2=>2,     3=>3,     4=>4,     5=>5,     6=>6,     7=>7,     8=>8,     9=>9,
+       10=>10,   11=>11,   12=>12,   13=>13,   14=>14,   15=>15,   16=>16,   17=>17,   18=>18,   19=>19,
+       20=>20,   21=>21,   22=>22,   23=>23,   24=>24,   25=>25,   26=>26,   27=>27,   28=>28,   29=>29,
+       30=>30,   31=>31,   32=>32,   33=>33,   34=>34,   35=>35,   36=>36,   37=>37,   38=>38,   39=>39,
+       40=>40,   41=>41,   42=>42,   43=>43,   44=>44,   45=>45,   46=>46,   47=>47,   48=>48,   49=>49,
+       50=>50,   51=>51,   52=>52,   53=>53,   54=>54,   55=>55,   56=>56,   57=>57,   58=>58,   59=>59,
+       60=>60,   61=>61,   62=>62,   63=>63,   64=>64,   65=>65,   66=>66,   67=>67,   68=>68,   69=>69,
+       70=>70,   71=>71,   72=>72,   73=>73,   74=>74,   75=>75,   76=>76,   77=>77,   78=>78,   79=>79,
+       80=>80,   81=>81,   82=>82,   83=>83,   84=>84,   85=>85,   86=>86,   87=>87,   88=>88,   89=>89,
+       90=>90,   91=>91,   92=>92,   93=>93,   94=>94,   95=>95,   96=>96,   97=>97,   98=>98,   99=>99,
+      100=>100, 101=>101, 102=>102, 103=>103, 104=>104, 105=>105, 106=>106, 107=>107, 108=>108, 109=>109,
+      110=>110, 111=>111, 112=>112, 113=>113, 114=>114, 115=>115, 116=>116, 117=>117, 118=>118, 119=>119,
+      120=>120, 121=>121, 122=>122, 123=>123, 124=>124, 125=>125, 126=>126)
+  end
+
+  # NODE_OP_ASGN
+  o = Object.new
+  class << o
+    attr_accessor :a
+  end
+
+  o.a = 1
+  assert_nothing_raised{ o.a += 1 }
+  o.a = 1
+  assert_nothing_raised{ o.a <<= 1 }
+  o.a = 1
+  assert_nothing_raised{ o.a &&= 1 }
+
+  o = { k: 1 }
+  assert_nothing_raised{ o[:k] += 1 }
+  o = { k: 1 }
+  assert_nothing_raised{ o[:k] <<= 1 }
+  o = { k: 1 }
+  assert_nothing_raised{ o[:k] &&= 1 }
+
+  o = { k: 1 }
+  assert_nothing_raised{ o[*[:k]] += 1 }
+  o = { k: 1 }
+  assert_nothing_raised{ o[*[:k]] <<= 1 }
+  o = { k: 1 }
+  assert_nothing_raised{ o[*[:k]] &&= 1 }
+
+  # NODE_YIELD
+  def check_node_yield
+    yield
+  end
+  assert_nothing_raised do
+    check_node_yield{}
+  end
+
+  # NODE_DXSTR
+  assert_raise(NotImplementedError){ `#{:dynamic}` }
+
+  # NODE_XSTR
+  assert_raise(NotImplementedError){ `static` }
+
+  # NODE_DREGX
+  class Regexp; end
+  assert_raise(NoMethodError){ /#{'dynamic'}tail/ }
+  assert_raise(NoMethodError){ /#{'dynamic'}tail/iu }
+
+  # NODE_REGX
+  assert_raise(NoMethodError){ /static/ }
+  assert_raise(NoMethodError){ /static/iu }
+  Object.__send__(:remove_const,:Regexp)
+
+  # NODE_UNDEF
+  assert_nothing_raised do
+    class << Object.new
+      undef inspect
+    end
+  end
+
+  # NODE_ALIAS
+  assert_nothing_raised do
+    class << Object.new
+      alias inspect2 inspect
+    end
+  end
+end