diff options
Diffstat (limited to 'spec/ruby/core/module/fixtures')
33 files changed, 799 insertions, 0 deletions
diff --git a/spec/ruby/core/module/fixtures/autoload.rb b/spec/ruby/core/module/fixtures/autoload.rb new file mode 100644 index 0000000000..5a77a2d9d4 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload.rb @@ -0,0 +1 @@ +$m.const_set(:AAA, "test") unless $m.nil? diff --git a/spec/ruby/core/module/fixtures/autoload_abc.rb b/spec/ruby/core/module/fixtures/autoload_abc.rb new file mode 100644 index 0000000000..ffaec91cfe --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_abc.rb @@ -0,0 +1,11 @@ +module ModuleSpecs::Autoload::FromThread + module A + class B + class C + def self.foo + :foo + end + end + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_c.rb b/spec/ruby/core/module/fixtures/autoload_c.rb new file mode 100644 index 0000000000..ff2bcc548c --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_c.rb @@ -0,0 +1,11 @@ +module ModuleSpecs::Autoload + class DynClass + class C + def loaded + :dynclass_c + end + end + end +end + +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_concur.rb b/spec/ruby/core/module/fixtures/autoload_concur.rb new file mode 100644 index 0000000000..0585e36880 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_concur.rb @@ -0,0 +1,9 @@ +ScratchPad.recorded << :con_pre +Thread.current[:in_autoload_rb] = true +sleep 0.1 + +module ModuleSpecs::Autoload + Concur = 1 +end + +ScratchPad.recorded << :con_post diff --git a/spec/ruby/core/module/fixtures/autoload_d.rb b/spec/ruby/core/module/fixtures/autoload_d.rb new file mode 100644 index 0000000000..6f5eee741c --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_d.rb @@ -0,0 +1,11 @@ +module ModuleSpecs::Autoload + module DynModule + class D + def loaded + :dynmodule_d + end + end + end +end + +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_e.rb b/spec/ruby/core/module/fixtures/autoload_e.rb new file mode 100644 index 0000000000..fb78c6cbd4 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_e.rb @@ -0,0 +1,7 @@ +module ModuleSpecs::Autoload + class E + def loaded + :autoload_e + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_empty.rb b/spec/ruby/core/module/fixtures/autoload_empty.rb new file mode 100644 index 0000000000..d7116f3049 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_empty.rb @@ -0,0 +1 @@ +# This file is left empty on purpose diff --git a/spec/ruby/core/module/fixtures/autoload_ex1.rb b/spec/ruby/core/module/fixtures/autoload_ex1.rb new file mode 100644 index 0000000000..a90092389c --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_ex1.rb @@ -0,0 +1,16 @@ + +class ModuleSpecs::Autoload::EX1 < Exception + def self.trample1 + 1.times { return } + end + + def self.trample2 + begin + raise "hello" + rescue + end + end + + trample1 + trample2 +end diff --git a/spec/ruby/core/module/fixtures/autoload_f.rb b/spec/ruby/core/module/fixtures/autoload_f.rb new file mode 100644 index 0000000000..54c2b05b7b --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_f.rb @@ -0,0 +1,7 @@ +module ModuleSpecs::Autoload + module F + def self.loaded + :autoload_f + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_g.rb b/spec/ruby/core/module/fixtures/autoload_g.rb new file mode 100644 index 0000000000..a1c4e429d9 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_g.rb @@ -0,0 +1,7 @@ +module ModuleSpecs::Autoload + class G + def loaded + :autoload_g + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_h.rb b/spec/ruby/core/module/fixtures/autoload_h.rb new file mode 100644 index 0000000000..53988c5382 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_h.rb @@ -0,0 +1,7 @@ +module ModuleSpecs::Autoload + module H + def loaded + :autoload_h + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_i.rb b/spec/ruby/core/module/fixtures/autoload_i.rb new file mode 100644 index 0000000000..f7f720516e --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_i.rb @@ -0,0 +1,5 @@ +module ModuleSpecs::Autoload + I = :autoloaded +end + +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_j.rb b/spec/ruby/core/module/fixtures/autoload_j.rb new file mode 100644 index 0000000000..da6d35d43d --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_j.rb @@ -0,0 +1,3 @@ +module ModuleSpecs::Autoload + J = :autoload_j +end diff --git a/spec/ruby/core/module/fixtures/autoload_k.rb b/spec/ruby/core/module/fixtures/autoload_k.rb new file mode 100644 index 0000000000..431602bf80 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_k.rb @@ -0,0 +1,7 @@ +module ModuleSpecs::Autoload + class KHash < Hash + K = :autoload_k + end +end + +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_lm.rb b/spec/ruby/core/module/fixtures/autoload_lm.rb new file mode 100644 index 0000000000..d93d783cd0 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_lm.rb @@ -0,0 +1,4 @@ +module ModuleSpecs::Autoload + L = :autoload_l + M = :autoload_m +end diff --git a/spec/ruby/core/module/fixtures/autoload_o.rb b/spec/ruby/core/module/fixtures/autoload_o.rb new file mode 100644 index 0000000000..6d54ddaf12 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_o.rb @@ -0,0 +1 @@ +# does not define ModuleSpecs::Autoload::O diff --git a/spec/ruby/core/module/fixtures/autoload_r.rb b/spec/ruby/core/module/fixtures/autoload_r.rb new file mode 100644 index 0000000000..34209d20c3 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_r.rb @@ -0,0 +1,4 @@ +module ModuleSpecs::Autoload + class R + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_s.rb b/spec/ruby/core/module/fixtures/autoload_s.rb new file mode 100644 index 0000000000..f5d412ff18 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_s.rb @@ -0,0 +1,5 @@ +module ModuleSpecs::Autoload + S = :autoload_s +end + +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_scope.rb b/spec/ruby/core/module/fixtures/autoload_scope.rb new file mode 100644 index 0000000000..04193687b5 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_scope.rb @@ -0,0 +1,8 @@ +module ModuleSpecs + module Autoload + class PP + class QQ + end + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_subclass.rb b/spec/ruby/core/module/fixtures/autoload_subclass.rb new file mode 100644 index 0000000000..569972118c --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_subclass.rb @@ -0,0 +1,11 @@ +class YY +end + +module ModuleSpecs + module Autoload + module XX + class YY < YY + end + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_t.rb b/spec/ruby/core/module/fixtures/autoload_t.rb new file mode 100644 index 0000000000..4962c97f4c --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_t.rb @@ -0,0 +1,3 @@ +module ModuleSpecs::Autoload::S + T = :autoload_t +end diff --git a/spec/ruby/core/module/fixtures/autoload_v.rb b/spec/ruby/core/module/fixtures/autoload_v.rb new file mode 100644 index 0000000000..2aa8c44169 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_v.rb @@ -0,0 +1,7 @@ +module ModuleSpecs::Autoload::U + class V + def self.get_value + :autoload_uvx + end + end +end diff --git a/spec/ruby/core/module/fixtures/autoload_w.rb b/spec/ruby/core/module/fixtures/autoload_w.rb new file mode 100644 index 0000000000..997273812e --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_w.rb @@ -0,0 +1,2 @@ +# Fails to define ModuleSpecs::Autoload::W::Y +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_w2.rb b/spec/ruby/core/module/fixtures/autoload_w2.rb new file mode 100644 index 0000000000..a8dbebf322 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_w2.rb @@ -0,0 +1 @@ +ScratchPad.record :loaded diff --git a/spec/ruby/core/module/fixtures/autoload_x.rb b/spec/ruby/core/module/fixtures/autoload_x.rb new file mode 100644 index 0000000000..a6c5842609 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_x.rb @@ -0,0 +1,3 @@ +module ModuleSpecs::Autoload + X = :x +end diff --git a/spec/ruby/core/module/fixtures/autoload_z.rb b/spec/ruby/core/module/fixtures/autoload_z.rb new file mode 100644 index 0000000000..cce1c13f37 --- /dev/null +++ b/spec/ruby/core/module/fixtures/autoload_z.rb @@ -0,0 +1,5 @@ +class ModuleSpecs::Autoload::YY +end + +class ModuleSpecs::Autoload::Z < ModuleSpecs::Autoload::YY +end diff --git a/spec/ruby/core/module/fixtures/classes.rb b/spec/ruby/core/module/fixtures/classes.rb new file mode 100644 index 0000000000..f93c39683e --- /dev/null +++ b/spec/ruby/core/module/fixtures/classes.rb @@ -0,0 +1,605 @@ +module ModuleSpecs + def self.without_test_modules(modules) + ignore = %w[MSpecRSpecAdapter PP::ObjectMixin ModuleSpecs::IncludedInObject MainSpecs::Module ConstantSpecs::ModuleA] + modules.reject { |k| ignore.include?(k.name) } + end + + CONST = :plain_constant + + module PrivConstModule + PRIVATE_CONSTANT = 1 + private_constant :PRIVATE_CONSTANT + PUBLIC_CONSTANT = 2 + end + + class Subclass < Module + end + + class SubclassSpec + end + + class RemoveClassVariable + end + + module LookupModInMod + INCS = :ethereal + end + + module LookupMod + include LookupModInMod + + MODS = :rockers + end + + class Lookup + include LookupMod + LOOKIE = :lookie + end + + class LookupChild < Lookup + end + + class Parent + # For private_class_method spec + def self.private_method; end + private_class_method :private_method + + def undefed_method() end + undef_method :undefed_method + + def parent_method; end + def another_parent_method; end + + # For public_class_method spec + private + def self.public_method; end + public_class_method :public_method + + public + def public_parent() end + + protected + def protected_parent() end + + private + def private_parent() end + end + + module Basic + def public_module() end + + protected + def protected_module() end + + private + def private_module() end + end + + module Super + include Basic + + def public_super_module() end + + protected + def protected_super_module() end + + private + def private_super_module() end + + def super_included_method; end + + class SuperChild + end + end + + module Internal + end + + class Child < Parent + include Super + + class << self + include Internal + end + attr_accessor :accessor_method + + def public_child() end + + undef_method :parent_method + undef_method :another_parent_method + + protected + def protected_child() end + + private + def private_child() end + end + + class Grandchild < Child + undef_method :super_included_method + end + + class Child2 < Parent + attr_reader :foo + end + + # Be careful touching the Counts* classes as there used for testing + # private_instance_methods, public_instance_methods, etc. So adding, removing + # a method will break those tests. + module CountsMixin + def public_3; end + public :public_3 + + def private_3; end + private :private_3 + + def protected_3; end + protected :protected_3 + end + + class CountsParent + include CountsMixin + + def public_2; end + + private + def private_2; end + + protected + def protected_2; end + end + + class CountsChild < CountsParent + def public_1; end + + private + def private_1; end + + protected + def protected_1; end + end + + module AddConstant + end + + module A + CONSTANT_A = :a + OVERRIDE = :a + def ma(); :a; end + def self.cma(); :a; end + end + + module B + CONSTANT_B = :b + OVERRIDE = :b + include A + def mb(); :b; end + def self.cmb(); :b; end + end + + class C + OVERRIDE = :c + include B + end + + module Z + MODULE_SPEC_TOPLEVEL_CONSTANT = 1 + end + + module Alias + def report() :report end + alias publish report + end + + class Allonym + include ModuleSpecs::Alias + end + + class Aliasing + def self.make_alias(*a) + alias_method(*a) + end + + def public_one; 1; end + + def public_two(n); n * 2; end + + private + def private_one; 1; end + + protected + def protected_one; 1; end + end + + class AliasingSubclass < Aliasing + end + + module AliasingSuper + + module Parent + def super_call(arg) + arg + end + end + + module Child + include Parent + def super_call(arg) + super(arg) + end + end + + class Target + include Child + alias_method :alias_super_call, :super_call + alias_method :super_call, :alias_super_call + end + + class RedefineAfterAlias + include Parent + + def super_call(arg) + super(arg) + end + + alias_method :alias_super_call, :super_call + + def super_call(arg) + :wrong + end + end + end + + + module ReopeningModule + def foo; true; end + module_function :foo + private :foo + end + + # Yes, we want to re-open the module + module ReopeningModule + alias :foo2 :foo + module_function :foo2 + end + + module Nesting + @tests = {} + def self.[](name); @tests[name]; end + def self.[]=(name, val); @tests[name] = val; end + def self.meta; class << self; self; end; end + + Nesting[:basic] = Module.nesting + + module ::ModuleSpecs + Nesting[:open_first_level] = Module.nesting + end + + class << self + Nesting[:open_meta] = Module.nesting + end + + def self.called_from_module_method + Module.nesting + end + + class NestedClass + Nesting[:nest_class] = Module.nesting + + def self.called_from_class_method + Module.nesting + end + + def called_from_inst_method + Module.nesting + end + end + + end + + Nesting[:first_level] = Module.nesting + + module InstanceMethMod + def bar(); :bar; end + end + + class InstanceMeth + include InstanceMethMod + def foo(); :foo; end + end + + class InstanceMethChild < InstanceMeth + end + + module ClassVars + class A + @@a_cvar = :a_cvar + end + + module M + @@m_cvar = :m_cvar + end + + class B < A + include M + + @@b_cvar = :b_cvar + end + end + + class CVars + @@cls = :class + + # Singleton class lexical scopes are ignored for class variables + class << self + def cls + # This looks in the parent lexical scope, class CVars + @@cls + end + # This actually adds it to the parent lexical scope, class CVars + @@meta = :metainfo + end + + def self.meta + @@meta + end + + def meta + @@meta + end + end + + module MVars + @@mvar = :mvar + end + + class SubModule < Module + attr_reader :special + def initialize + @special = 10 + end + end + + module MA; end + module MB + include MA + end + module MC; end + + class MultipleIncludes + include MB + end + + # empty modules + module M1; end + module M2; end + + module Autoload + def self.use_ex1 + begin + begin + raise "test exception" + rescue ModuleSpecs::Autoload::EX1 + end + rescue RuntimeError + return :good + end + end + + module FromThread + module A + autoload :B, fixture(__FILE__, "autoload_empty.rb") + + class B + autoload :C, fixture(__FILE__, "autoload_abc.rb") + + def self.foo + C.foo + end + end + end + + class D < A::B; end + end + end + + # This class isn't inherited from or included in anywhere. + # It exists to test the constant scoping rules. + class Detached + DETACHED_CONSTANT = :d + end + + class ParentPrivateMethodRedef + private + def private_method_redefined + :before_redefinition + end + end + + class ChildPrivateMethodMadePublic < ParentPrivateMethodRedef + public :private_method_redefined + end + + class ParentPrivateMethodRedef + def private_method_redefined + :after_redefinition + end + end + + module CyclicAppendA + end + + module CyclicAppendB + include CyclicAppendA + end + + module CyclicPrepend + end + + module ExtendObject + C = :test + def test_method + "hello test" + end + end + + module ExtendObjectPrivate + class << self + def extend_object(obj) + ScratchPad.record :extended + end + private :extend_object + end + end + + class CyclicBarrier + def initialize(count = 1) + @count = count + @state = 0 + @mutex = Mutex.new + @cond = ConditionVariable.new + end + + def await + @mutex.synchronize do + @state += 1 + if @state >= @count + @state = 0 + @cond.broadcast + true + else + @cond.wait @mutex + false + end + end + end + + def enabled? + @mutex.synchronize { @count != -1 } + end + + def disable! + @mutex.synchronize do + @count = -1 + @cond.broadcast + end + end + end + + class ThreadSafeCounter + def initialize(value = 0) + @value = 0 + @mutex = Mutex.new + end + + def get + @mutex.synchronize { @value } + end + + def increment_and_get + @mutex.synchronize do + prev_value = @value + @value += 1 + prev_value + end + end + end + + module ShadowingOuter + module M + SHADOW = 123 + end + + module N + SHADOW = 456 + end + end + + module UnboundMethodTest + def foo + 'bar' + end + end + + module ClassEvalTest + def self.get_constant_from_scope + module_eval("Lookup") + end + + def self.get_constant_from_scope_with_send(method) + send(method, "Lookup") + end + end + + class RecordIncludedModules + def self.inherited(base) + ScratchPad.record base + end + end + + module SingletonOnModuleCase + module Foo + class << Foo + def included(base) + base.included_called + super + end + end + end + + class Bar + @included_called = false + + class << self + def included_called + @included_called = true + end + + def included_called? + @included_called + end + end + end + end + + module CaseCompareOnSingleton + def self.===(*) + raise 'method contents are irrelevant to test' + end + end + + m = Module.new do + def foo + end + private :foo + end + EmptyFooMethod = m.instance_method(:foo) +end + +class Object + def module_specs_public_method_on_object; end + + def module_specs_private_method_on_object; end + private :module_specs_private_method_on_object + + def module_specs_protected_method_on_object; end + protected :module_specs_private_method_on_object + + def module_specs_private_method_on_object_for_kernel_public; end + private :module_specs_private_method_on_object_for_kernel_public + + def module_specs_public_method_on_object_for_kernel_protected; end + def module_specs_public_method_on_object_for_kernel_private; end +end + +module Kernel + def module_specs_public_method_on_kernel; end + + alias_method :module_specs_alias_on_kernel, :module_specs_public_method_on_object + + public :module_specs_private_method_on_object_for_kernel_public + protected :module_specs_public_method_on_object_for_kernel_protected + private :module_specs_public_method_on_object_for_kernel_private +end + +ModuleSpecs::Nesting[:root_level] = Module.nesting diff --git a/spec/ruby/core/module/fixtures/constant_unicode.rb b/spec/ruby/core/module/fixtures/constant_unicode.rb new file mode 100644 index 0000000000..415911576d --- /dev/null +++ b/spec/ruby/core/module/fixtures/constant_unicode.rb @@ -0,0 +1,5 @@ +# encoding: utf-8 + +module ConstantUnicodeSpecs + CS_CONSTλ = :const_unicode +end diff --git a/spec/ruby/core/module/fixtures/module.rb b/spec/ruby/core/module/fixtures/module.rb new file mode 100644 index 0000000000..9050a272ec --- /dev/null +++ b/spec/ruby/core/module/fixtures/module.rb @@ -0,0 +1,4 @@ +module ModuleSpecs + module Anonymous + end +end diff --git a/spec/ruby/core/module/fixtures/name.rb b/spec/ruby/core/module/fixtures/name.rb new file mode 100644 index 0000000000..fb9e66c309 --- /dev/null +++ b/spec/ruby/core/module/fixtures/name.rb @@ -0,0 +1,10 @@ +# -*- encoding: utf-8 -*- +module ModuleSpecs + class NameEncoding + class Cß + end + def name + Cß.name + end + end +end diff --git a/spec/ruby/core/module/fixtures/path1/load_path.rb b/spec/ruby/core/module/fixtures/path1/load_path.rb new file mode 100644 index 0000000000..d4c45463dc --- /dev/null +++ b/spec/ruby/core/module/fixtures/path1/load_path.rb @@ -0,0 +1,9 @@ +$LOAD_PATH.unshift(File.expand_path('../../path2', __FILE__)) + +module ModuleSpecs::Autoload + module LoadPath + def self.loaded + :autoload_load_path + end + end +end diff --git a/spec/ruby/core/module/fixtures/path2/load_path.rb b/spec/ruby/core/module/fixtures/path2/load_path.rb new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/spec/ruby/core/module/fixtures/path2/load_path.rb @@ -0,0 +1 @@ + diff --git a/spec/ruby/core/module/fixtures/repeated_concurrent_autoload.rb b/spec/ruby/core/module/fixtures/repeated_concurrent_autoload.rb new file mode 100644 index 0000000000..32b770e6cf --- /dev/null +++ b/spec/ruby/core/module/fixtures/repeated_concurrent_autoload.rb @@ -0,0 +1,8 @@ +prev_value = ScratchPad.recorded.increment_and_get +eval <<-RUBY_EVAL + module Mod#{prev_value} + sleep(0.05) + def self.foo + end + end +RUBY_EVAL |